Python学习(一)

目录

文章目录

• 目录
• 一,Python介绍
• 1.1 Python介绍
• 1.2 关键点常识
• 1.3 Python优缺点
• 1.4 Python应用场景
• 二,python安装下载
• 2.1 windows下安装python
• 2.2 linux下安装python
• 三,python语法
• 3.1 python的注释及乱码
• 3.2 变量及类型
• 3.2.1 变量的定义
• 3.2.2 变量的类型
• 1.整数
• 2.浮点数
• 3.字符串
• 4.布尔值
• 5.空值
• 3.2.3 常见的数据类型转换
• 3.3 标识符和关键字
• 1.标识符
• 2.标示符的规则
• 3.关键字
• 3.4 输入与输出
• 1.标准输出
• 2.格式化输出
• 3.输入
• 3.5 运算符
• 1.算术运算符
• 2.赋值运算符
• 3.复合赋值运算符
• 4.逻辑运算符
• 5.比较（关系）运算符
• 3.6 逻辑判断和循环
• 3.6.1 if elif else条件判断
• 3.6.2 input陷阱
• 3.6.3 if嵌套的格式
• 3.7 循环结构
• 1. while循环
• 2.while循环嵌套
• 3.for循环
• 4.break和continue
• 四,集合类型
• 4.1 字符串String
• 1.下标索引
• 2.切片(分片)
• 3.字符串常见操作
• 4.2 列表List
• 列表的相关操作
• 4.3 元组tuple
• 1.访问
• 2.修改
• 3.“可变的”tuple
• 4. 元组的内置函数count, index
• 4.4 字典dict和set
• 4.4.1 字典的介绍
• 4.4.2 字典的常见操作
• result
• 4.4.3 字典的常见函数
• 4.4.4 字典遍历
• 4.4.5 set
• 字典总结
• 4.5 可变类型与不可变类型
• 五,Python的函数
• 5.1 函数的定义与调用
• 1.定义函数
• 2.调用函数
• 5.2 函数的参数
• 1.定义带有参数的函数
• 2.调用带有参数的函数
• 3.带有默认值的参数(缺省参数)
• 4.不定长(可变)参数
• 5.引用传参
• 5.3 函数返回值
• 5.4 局部变量和全局变量
• 1.局部变量
• 2.全局变量
• 总结
• 5.5 递归函数
• 5.6 匿名函数
• 1.匿名函数
• 2.应用场合
• 小程序:计算器的实现
• 六,Python的文件操作
• 6.1 文件的打开与关闭
• 1.打开文件
• 2.关闭文件
• 6.2 文件的读写
• 1.写数据(write)
• 2.文件的读写
• 1.read
• 2.readline
• 3.readlines
• 区别
• 6.3 文件的定位读写
• 1.获取当前读写的位置tell
• 2.定位到某个位置
• 6.4 文件的相关操作
• 6.5 路径补充

一,Python介绍

1.1 Python介绍

一种面向对象，面向函数的解释型计算机程序设计语言,函数式编程（函数可以作为参数传递）

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

• Python的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
• Python是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python是交互式语言： 这意味着，我们可以在一个Python提示符后面直接互动执行写自己的程序。
• Python是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python是初学者的语言：Python简单易学，对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

用途：机器学习，爬虫，服务器脚本，web，网络协议

解释器：Cpython,JPython,PyPython

版本：2.7.15，3.6.4

优缺点：简单，易学，免费开源，高层语言（不需要考虑程序所使用的内存大小），可移植性，面向对象，可扩展性，拥有丰富的库NumPy 用于科学计算机器学习，规范代码（强制缩进）

应用场景：web应用开发Django，操作系统管理、服务器运维的自动化脚本，科学计算机器学习NumPy，服务器软件(网络软件)阿里云

1.2 关键点常识

1. Python的发音与拼写
2. Python的意思是蟒蛇，源于作者喜欢的一部电视剧 (C呢？)
3. Python的作者是Guido van Rossum（龟叔）
4. Python是龟叔在1989年圣诞节期间，为了打发无聊的圣诞节而用C编写的一个编程语言
5. Python正式诞生于1991年
6. Python的解释器如今有多个语言实现，我们常用的是CPython（官方版本的C语言实现），其他还有Jython（可以运行在Java平台）、IronPython（可以运行在.NET和Mono平台）、PyPy（Python实现的，支持JIT即时编译）
7. Python目前有两个版本，Python2和Python3，最新版分别为2.7.13和3.6.2

1.3 Python优缺点

• 简单————Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。
• 易学————就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法。
• 免费、开源————Python是FLOSS（自由/开放源码软件）之一。简单地说，你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。这是为什么Python如此优秀的原因之一——它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。
• 高层语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。不需要考虑程序所使用的内存大小
• 可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就可以在下述任何平台上面运行。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE甚至还有PocketPC、Symbian以及Google基于linux开发的Android平台！
• 解释性————这一点需要一些解释。一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。
• 面向对象————Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。
• 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
• 丰富的库————Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
• 规范的代码————Python采用强制缩进的方式使得代码具有极佳的可读性。

1.4 Python应用场景

• Web应用开发
  Python经常被用于Web开发。比如，通过mod_wsgi模块，Apache可以运行用Python编写的Web程序。Python定义了WSGI标准应用接口来协调Http服务器与基于Python的Web程序之间的通信。一些Web框架，如Django,TurboGears,web2py,Zope等，可以让程序员轻松地开发和管理复杂的Web程序。
• 操作系统管理、服务器运维的自动化脚本
  在很多操作系统里，Python是标准的系统组件。 大多数Linux发行版以及NetBSD、OpenBSD和Mac OS X都集成了Python，可以在终端下直接运行Python。有一些Linux发行版的安装器使用Python语言编写，比如Ubuntu的Ubiquity安装器,Red Hat Linux和Fedora的Anaconda安装器。Gentoo Linux使用Python来编写它的Portage包管理系统。Python标准库包含了多个调用操作系统功能的库。通过pywin32这个第三方软件 包，Python能够访问Windows的COM服务及其它Windows API。使用IronPython，Python程序能够直接调用.Net Framework。一般说来，Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本。
• 科学计算机器学习
  NumPy,SciPy,Matplotlib可以让Python程序员编写科学计算程序。
• 服务器软件（网络软件）——阿里云
  Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫。第三方库Twisted支持异步网络编程和多数标准的网络协议(包含客户端和服务器)，并且提供了多种工具，被广泛用于编写高性能的服务器软件。

二,python安装下载

2.1 windows下安装python

1. 安装python3环境

   Anaconda3-5.2.0-Windows-x86_64.exe

   在这个页面全勾选

   

   此时可在cmd中执行python命令。

2. 安装python2环境

   python-2.7.15.amd64.msi

PythonIDE的安装：

（1）eclipse插件安装

​ Help—> eclipse marketplace—> pydev(较慢)

插件包：加压拷贝到eclipse的dropins中，重启即可

（2）pycharm安装

​ 傻瓜式安装，创建新的项目的时候直接选择sdk

在cmd窗口中支持交互式窗口： ipython

安装：pip install ipython 执行：ipython

支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数

注意：Python中本身不带有这个ipython的交互，需要自行安装。首先查看计算机中是否包含pip，一般安装完之后可能会有错，执行python –m pip install –upgrade pip,先将pip进行更新，然后安装ipython：pip install ipython

1、下载python
1) 下载地址：https://www.python.org/downloads/release/python-364/
2) 解压到F:\Python36
3) 将F:\Python36，F:\Python36\Scripts添加到PATH环境变量中
4) 更改pip的源
在C:\Users\<username>\创建pip目录，其中添加pip.ini
在pip.ini中添加如下语句：
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host=mirrors.aliyun.com
5) 打开cmd，输入pip install ipython进行安装
6) 打开cmd，输入python -m pip install --upgrade pip升级pip

2、下载和安装Anaconda
Anaconda各个版本的下载地址：
https://repo.anaconda.com/archive/

3、下载和使用PyDev
PyDev 6.4.4.zip下载地址：
https://excellmedia.dl.sourceforge.net/project/pydev/pydev/PyDev%206.4.4/PyDev%206.4.4.zip
	
Need to use older Eclipse/Java/Python
If you need to use an older version of Eclipse/Java/Python, below is the latest PyDev version to be used based on your requisites.
•	Eclipse 4.5, Java 8: PyDev 5.2.0
•	Eclipse 3.8, Java 7: PyDev 4.5.5
•	Eclipse 3.x, Java 6: PyDev 2.8.2
•	Python 2.5 or older: PyDev 5.5.0
	
将下载的zip包解压后放到eclipse的dropin目录中重启eclipse即可。
在pycharm中禁止使用test开头的py文件，默认是单元测试。Eclipse中随意


input和raw_input的区别在于：input会将输入的字符串看作是变量名称，而raw_input不会
input和raw_input的区别在python2中出现，python3中没有这个问题了。

在环境变量配置：
Anaconda3的Library\bin
Anaconda3的根目录
Anaconda3的Scripts

其他的python2和python3从环境变量删除

2.2 linux下安装python

Python2.x

1、 下载Python2.x的包

2、 tar –zxvf python-2.7.15.tar

3、 yum install gcc

4、 ./configure

5、 Make && make install

Python3.x

1、 依赖环境：yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel

2、 下载Python3的包

3、 tar –zxvf python-3.6.1.tgz

4、 ./configure

5、 Make && make install

6、 添加环境变量

三,python语法

3.1 python的注释及乱码

1. 单行注释：以#开头，#右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用

2. 多行注释：’’’多行注释’’’可以写多行的功能说明

   '''
   单行注释使用#
   多行注释使用'''
   '''
   '''
   print("hello python")
   

3. Python乱码问题

   由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

   # -*- coding:utf-8 -*-
   # coding=utf-8
   

​ 注意:idea不要使用test开头来作为文件名,因为test开头会默认为是测试文件,eclipse无所谓

3.2 变量及类型

3.2.1 变量的定义

在Python中，存储一个数据，需要一个叫做变量的东西：

例如：num1=100

​ Num2=87

​ Result=num1+num2

变量三要素：变量的名称，变量的类型，变量的值

3.2.2 变量的类型

• 定义在类外的叫函数function,定义在类里面的叫方法method

  class Person:
      def eat(self):# 方法:定义在类里面的叫方法
          print("person.run")
  
  def fun():# 函数:定义在类外的叫函数
      print("fun")
  fun()
  Person.eat()
  

• object 必须小写o

1.整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

2.浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

3.字符串

字符串是**以单引号'或双引号"**括起来的任意文本，比如'abc'，"xyz"等等。请注意，’‘或"“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”"括起来，比如"I’m OK"包含的字符是I，’，m，空格，O，K这6个字符。

如果字符串内部既包含’又包含"怎么办？可以用转义字符\来标识，比如：

'I\'m \"OK\"!'

表示的字符串内容是：

I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r’‘表示’'内部的字符串默认不转义，可以自己试试：

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用’’’…’’'的格式表示多行内容，

print('''hello
world
python
''')

4.布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来

布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True：

5.空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型

怎样知道一个变量的类型呢？

在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别

可以使用type(变量的名字)，来查看变量的类型

a=10
a="abcd"
a=3.14
print(a)
print(type(a))
b='qwer'
print(b)
print(type(b))
str1='i\'m ok'
str2="i'm ok"
print(str1)
print(str2)
print('''hello
world
python
''')
flag=True
flag=False
str=None

3.2.3 常见的数据类型转换

a="123"
b=int(a)
print(type(b))

3.3 标识符和关键字

1.标识符

开发人员在程序中自定义的一些符号和名称，标示符是自己定义的,如变量名 、函数名等

2.标示符的规则

• 标示符由字母、下划线和数字组成
• 数字不能开头
• 不能有特殊符号：,/,;,#
• python中的标识符是区分大小写的

思考：下面的标示符哪些是正确的，哪些不正确为什么

fromNo12 from#12 my_Boolean my-Boolean Obj2 2ndObj myInt

test1 Mike2jack My_tExt _test test!32haha(da)ttint jack_rose jack&rose GUI G.U.I

不正确:from#12 2ndObj test!32haha(da)ttint jack&rose G.U.I

​ 注意:pycharm不要使用test开头来作为文件名,因为test开头会默认为是测试文件,eclipse无所谓

命名规则：见名知义、驼峰式命名

3.关键字

python一些具有特殊功能的标示符，这就是所谓的关键字

关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符

查看关键字:(保留字)

And as assert break class continue def

del elif else except exec finally for

from global if in import is lambda

not or pass print raise return try

while with yield

可以通过以下命令进行查看当前系统中python的关键字：

import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

简介

1. and：表示逻辑‘与’

2. del：用于list列表操作，删除一个或者连续几个元素。

3. from：导入相应的模块，用import或者from…import

4. not：表示逻辑‘非’

5. while：while循环，允许重复执行一块语句，一般无限循环的情况下用它

6. as：as单独没有意思，是这样使用：with…as用来代替传统的try…finally语法的。

7. elif:和if配合使用的，if语句中的一个分支用elif表示。

8. global :定义全局变量

   例如：

   name = 10
   age = 20
   def test():
   global name
   age = 30
   name = 'aa'
   #print(name)
   test()
   print(name)        # 'aa'
   print(age)            # 20
   
   

9. or：表示逻辑“或”

10. with：和as一起用，使用的方法请看as，见with

11. assert：表示断言（断言一个条件就是真的，如果断言出错则抛出异常）用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError

    v1 = 10
    v2 = 20
    assert(v1 > v2)
    
    

12. else：参考下面if的解释

13. if：if语句用于选择分支，依据条件选择执行那个语句块。(if语句中最好不要嵌套if语句，建议把嵌套的if语句写在另一个函数中)

14. pass：pass的意思就是什么都不做(当方法内不想写东西时可以将pass写入方法)

    def fun():
        pass
    fun()
    
    

15. yield：用起来和return很像，但它返回的是一个生成器

16. break：作用是终止循环，程序走到break的地方就是循环结束的时候。

17. except：和try一起使用，用来捕获异常。

18. import：用来导入模块，有时这样用from…import

19. class：定义类

20. in：查找列表中是否包含某个元素，或者字符串a是否包含字符串b。

21. raise：raise可以显示地引发异常。一旦执行raise语句，后面的代码就不执行了

22. continue：跳过continue后面循环块中的语句，继续进行下一轮循环。

23. finally:看到finally语句，必然执行finally语句的代码块。

24. is：Python中的对象包含三要素：id、type、value,用来判断对象是否相等

25. return：用于跳出函数，也可以在跳出的同时返回一个值。

26. def：用于定义方法

27. for：for…in 一起使用：它在一序列的对象上递归，就是遍历队列中的每个项目

28. lambda:即匿名函数

29. try：出现在异常处理中，使用格式为：try…except，try中放想要执行的语句，except捕获异常

30. nonlocal：nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

    例如：

    def make_counter():
        count = 0
        def counter():
            nonlocal count
            count += 1
            return count
        return counter
    
    
    def make_counter_test():
        mc = make_counter()
        print(mc())
        print(mc())
        print(mc())
    make_counter_test()
    
    

3.4 输入与输出

1.标准输出

用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。

print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出：

print("hello","world",678)

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

hello world 678

print()也可以打印整数，或者计算结果

print(100+200)

因此，我们可以把计算100 + 200的结果打印得更漂亮一点：

print('100 + 200 =', 100 + 200)

2.格式化输出

%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

print("%d+%d=%d"%(100,200,300))
abc="hello"
print("%s,world"%"hello")
print("%s,world"%abc)
100+200=300
hello,world
hello,world

常见的占位符有：

%d 整数

%f 浮点数

%s 字符串

%x 十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

f=123.456
print("%.1f"%f)
print("%.2f"%f)
print("%2d-%02d"%(3,1))
结果
123.5
123.46
 3-01

如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串

有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

print("growth rate:%d%%"%7)
growth rate:7%

3.输入

Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里

1.python2版本中

1. raw_input()

   在Python中，获取键盘输入的数据的方法是采用 raw_input 函数。

   看如下示例:

   注意:

   raw_input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示

   raw_input()在从键盘获取了数据以后，会存放到等号右边的变量中

   raw_input()会把用户输入的任何值都作为字符串来对待

2. input()

   input()函数与raw_input()类似，但其接受的输入作为是表达式。

   input()接受表达式输入，并把表达式的结果赋值给等号左边的变量

   raw_input()输入的都当成字符串（和Python3的input功能一样）

注意:py2版本的input()只能跟表达式,如果要跟字符串必须加双引号引起来

>>> s=input("请输入字符串:")
请输入字符串:abc
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'abc' is not defined
>>> s=input("请输入字符串:")
请输入字符串:123
>>> print(s)
123
>>> s=input("请输入字符串:")
请输入字符串:"abc"
>>> print(s)
abc
>>> s=raw_input("请输入")
请输入abc
>>> print(s)
abc
>>> abc="cw"
>>> a=input("请输入:")
请输入:abc
>>> print(a)
cw

2.python3版本中

没有raw_input()函数，只有input()

并且 python3中的input与python2中的raw_input()功能一样

input()接收的数据均为String类型

s=input("请输入数字:")
print(s)
s=input("请输入字符串:")
print(s)
结果
请输入数字:18
18
请输入字符串:abc
abc

3.5 运算符

1.算术运算符

下面以a=10 ,b=20为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	x除以y b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余（取模）	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000

print(10/3)
print(10//3)
print(10//3.0)
print(2**3)
结果
3.3333333333333335
3
3.0
8

2.赋值运算符

运算符	描述	实例
=	赋值运算符	把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7

>>> a, b = 1, 2
>>> a 
1
>>> b 
2

3.复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

注意：Python中没有a++,a–,++a,–a等操作

4.逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

5.比较（关系）运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.

3.6 逻辑判断和循环

3.6.1 if elif else条件判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>
    
age = input("请输入年龄:")
age = int(age)
if (age < 20):
    print("小孩")
elif (age < 40):
    print("青年")
else:
    print("老年")

if判断条件还可以简写，比如写：

if x:
    print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

3.6.2 input陷阱

最后看一个有问题的条件判断。很多同学会用input()读取用户的输入，这样可以自己输入，程序运行得更有意思：

birth = input('birth: ')
if birth < 2000:
    print('00前')
else:
    print('00后')

输入1982，结果报错：

这是因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情：

s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

再次运行，就可以得到正确地结果。但是，如果输入abc呢？又会得到一个错误信息：

Traceback (most recent calllast):

  File "<stdin>", line 1, in <module>

ValueError: invalid literal forint() with base 10: 'abc'

原来int()函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。

如何检查并捕获程序运行期的错误呢？后面的错误和调试会讲到。

3.6.3 if嵌套的格式

if 条件1:
	满足条件1 做的事情1 
	满足条件1 做的事情2 
	...(省略)... 
	if 条件2: 
		满足条件2 做的事情1 
		满足条件2 做的事情2 
	...(省略)... 
说明：
外层的if判断，也可以是if-else
内层的if判断，也可以是if-else
根据实际开发的情况，进行选择

案例

1. 要求：从键盘输入刀子的长度，如果刀子长度没有超过10cm，则允许上火车，否则不允许上火车

   length=input("请输入小刀的长度:")
   length=int(length)
   if(length<=10):
       print("允许上车,长度为:%d"%length)
   else:
       print("不允许上车,长度为:%d,超出范围:10"%length)
   
   

2. 小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

   低于18.5：过轻

   18.5-25：正常

   25-28：过重

   28-32：肥胖

   高于32：严重肥胖

   用if-elif判断并打印结果：

   high=input("请输入身高(m)\n")
   weight=input("请输入体重(kg)\n")
   high=float(high)
   weight=float(weight)
   BMI=weight/(high**2)
   if(BMI<18.5):
       print("BMI:%f,过轻"%BMI)
   elif(BMI<25):
       print("BMI:%f,正常"%BMI)
   elif(BMI<28):
       print("BMI:%f,过重"%BMI)
   elif(BMI<32):
       print("BMI:%f,肥胖"%BMI)
   else:
       print("BMI:%f,严重肥胖"%BMI)
   
   

3.7 循环结构

Python的循环有两种，一种是for…in循环，另外一种是while循环。

1. while循环

while 条件:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...

• pass 和while没有关系

1. 计算1~100的累积和（包含1和100）
# encoding=utf-8
i = 1
sum = 0
while i <= 100:
    sum = sum + i
    i += 1
print("1~100的累积和为:%d" % sum)
2. 计算1~100之间偶数的累积和（包含1和100）
# encoding=utf-8
i = 1
sum = 0
while i <= 100:
    if (i % 2 == 2):
        sum = sum + i
    i += 1
print("1~100的偶数的累积和为:%d" % sum)

2.while循环嵌套

while 条件1:
        条件1满足时，做的事情1
        条件1满足时，做的事情2
        条件1满足时，做的事情3
        ...(省略)...
        while 条件2:
            条件2满足时，做的事情1
            条件2满足时，做的事情2
            条件2满足时，做的事情3
            ...(省略)...

1.要求：打印如下图形： m行，每行打印n次，n==m
*
* *
* * * 
* * * * 
* * * * *
i = 1
while (i <= 5):
    j = 1
    while (j <= i):
        print("*", end=' ')
        j += 1
    print()
    i += 1

2. 九九乘法表
i = 1
while (i <= 9):
    j = 1
    while (j <= i):
        print("%d*%d=%d" % (i, j, i * j), end='\t')
        j += 1;
    print()
    i += 1

3.for循环

像while循环一样，for可以完成循环的功能。

在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

for 临时变量 in 列表或者字符串等:
        循环满足条件时执行的代码
    else:
        循环不满足条件时执行的代码

Range函数

# for i in 1,2,3,4,5,6,7,8,9,10:
#     print(i)
# for i in range(1,10):
#     print(i)

#输出1,3,5,7,9
# for i in range(1,10,2):
#     print(i)
for i in "asf":
    print(i)
for i in "asf","dfsdf","sdfsd":
    print(i)
else:
    print("循环完了")
输出
a
s
f
asf
dfsdf
sdfsd
循环完了

九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d"%(i,j,i*j),end='\t')
    print()

4.break和continue

1. break

   在循环中，break语句可以提前退出循环。例如，本来要循环打印1～100的数字：

   n = 1
   while n <=100:
       print(n)
       n = n + 1
   print('END')
   
   

   上面的代码可以打印出1~100。

   如果要提前结束循环，可以用break语句：

   n = 1
   while n <= 100:
       print(n)
       if n > 10:  # 当n = 11时，条件满足，执行break语句
           break  # break语句会结束当前循环print(n)
       n = n + 1
   print('END')
   
   

2. continue

   在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

   n = 0
   while n < 10:
       n = n + 1
       if n % 2 == 0:  # 如果n是偶数，执行continue语句continue
           continue  # continue语句会直接继续下一轮循环，后续的print()语句不会执行
       print(n)
   
   

四,集合类型

4.1 字符串String

String字符串：不可变类型

1.下标索引

所谓下标，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间

字符串实际上就是字符的数组，所以也支持下标索引,可通过下标索引来获取对应位置的值

从左边数下标是从0开始，从右边数是从-1开始。

如果有字符串:name = ‘abcdef’，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意python中从左边数下标是从0开始，从右边数是从-1开始。）

name = 'abcdef'
print(name[0]) # a
print(name[1]) # b 
print(name[-2]) # e

2.切片(分片)

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。类似substring

切片的语法：

[起始:结束:步长]

步长：表示下标变化的规律。

注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。

我们以字符串为例讲解。

如果取出一部分，则可以在中括号[]中，使用:

注意:如果步长为负数,则代表从右往左列出,起始位置要比介绍位置索引大

3.字符串常见操作

如有字符串mystr = ‘hello world and bjsxt yunshuxueyuan sxt beijing’，以下是常见的操作

<1>find == java Indexof方法

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

返回指定子串在str中从左边数第一次出现的位置的下标

mystr.find(str, start=0, end=len(mystr))

<2>index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

返回指定子串在str中从左边数第一次出现的位置的下标

mystr.index(str, start=0, end=len(mystr))

<3>count

返回 str在start和end之间 在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))

<4>replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

mystr.replace(str1, str2, mystr.count(str1))

<5>split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

mystr.split(str=" ", 2)

<6>capitalize

把字符串的第一个字符大写

mystr.capitalize()

<7>title

把字符串的每个单词首字母大写

<8>startswith

检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

mystr.startswith(obj)

<9>endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False.

mystr.endswith(obj)

<10>lower

转换 mystr 中所有大写字符为小写

mystr.lower()

<11>upper

转换 mystr 中的小写字母为大写

mystr.upper()

<12>ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

mystr.ljust(width)

mystr.ljust(width,字符):可以自定义字符设置为填充字符如mystr.ljust(width,’*’)

<13>rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)

<14>center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

mystr.center(width)

print(mystr.center(100,’*’))

mystr = 'hello world'
print(mystr.ljust(30,'*'))
print(mystr.rjust(30,'*'))
print(mystr.center(30,'*'))
print("*"*30)
结果
hello world*******************
*******************hello world
*********hello world**********
******************************

<15>lstrip

删除 mystr 左边的空白字符

mystr.lstrip()

<16>rstrip

删除 mystr 字符串末尾的空白字符

mystr.rstrip()

<17>strip —java trim

删除mystr字符串两端的空白字符

<18>rfind

类似于 find()函数，不过是从右边开始查找.返回指定子串在str中从右边数第一次出现的位置的下标

mystr.rfind(str, start=0,end=len(mystr) )

<19>rindex 返回指定子串在str中从右边数第一次出现的位置的下标

类似于 index()，不过是从右边开始.

mystr.rindex( str, start=0,end=len(mystr))

<20>partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

<21>rpartition

类似于 partition()函数,不过是从右边开始.

mystr.rpartition(str)

<22>splitlines

按照换行符分隔，返回一个包含各行作为元素的列表

mystr.splitlines()

<23>isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

mystr.isalpha()

<24>isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

mystr.isdigit()

<25>isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

mystr.isalnum()

<26>isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

mystr.isspace()

<27>join

mystr 中每个字符后面插入list的每个元素后面,构造出一个新的字符串

mystr.join(list)

mystr = 'hello world'
print(mystr.join(['first ',' second ',' third']))# 将mystr添加到每个集合成员之间
print(mystr.join(['first ',' second ',' third ',' forth']))

first hello world second hello world third
first hello world second hello world third hello world forth

注意:

查找字符串：

• find：找不到返回-1 ，都是从左边找，右边查找r
• index：找不到报错

str.index(“指定子串”) ：返回指定子串在str中从左边数第一次出现的位置的下标
str.rindex(“指定子串”) ：返回指定子串在str中从右边数第一次出现的位置的下标
以上两方法如果找不到指定子串会报错。
str.find(“指定子串”) ：返回指定子串在str中从左边数第一次出现的位置的下标
str.rfind(“指定子串”) ：返回指定子串在str中从右边数第一次出现的位置的下标
以上两方法如果找不到指定子串时就会返回-1

4.2 列表List

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

列表用[ ]标识，用len()函数可以获取list元素个数，可以用下标索引来获取指定位置的元素。

列表中的数据是可以进行修改的。

比如，列出班里所有同学的名字，就可以用一个list表示：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']
变量classmates就是一个list。用len()函数可以获得list元素的个数：
>>> len(classmates)
3
用索引来访问list中每一个位置的元素，记得索引是从0开始的：
>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。
如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：
>>> classmates[-1]
'Tracy'

列表的相关操作

列表中存放的数据是可以进行修改的，比如"增"、“删”、“改”"

1.添加元素("增"append, extend, insert)

a.append(b) :将b完整追加到a中

a.extend(b):将表中元素一个一个取出来加到a中

a.insert(index,object): 在指定位置index前插入元素object

list = ["hello", 123, True, 345.678]
list2 = ["q", "w", "e"]
list3 = ["q", ["w", "e"]]
list.append("qwer")
print(list)
list.insert(2, "qqq")
print(list)
list.extend(list2)
print(list)
list.extend(list3)
print(list)

['hello', 123, True, 345.678, 'qwer']
['hello', 123, 'qqq', True, 345.678, 'qwer']
['hello', 123, 'qqq', True, 345.678, 'qwer', 'q', 'w', 'e']
['hello', 123, 'qqq', True, 345.678, 'qwer', 'q', 'w', 'e', 'q', ['w', 'e']]

2.修改

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

list = ["hello", 123, True, 345.678]
list[0]="world"
print(list)
显示为:
['world', 123, True, 345.678]

3.查找

所谓的查找，就是看看指定的元素是否存在

in（存在）,如果存在那么结果为true，否则为false

not in（不存在），如果不存在那么结果为true，否则false

index, count index和count与字符串中的用法相同

findName="李四"
nameList=["张三","李四","王五"]
#查找是否存在
if findName in nameList:
    print('在字典中找到了相同的名字')
else:
    print('没有找到')
    
a = ['a', 'b', 'c', 'a', 'b']
print(a.index('a', 0, 3)) # 注意是左闭右开区间
print(a.index('a', 0, -1)) # 注意是左闭右开区间
print(a.count('a')) 


在字典中找到了相同的名字
0
0
2

4删除：

del：根据下标进行删除，其实可以删除所有变量

pop：默认删除最后一个元素

remove：根据元素的值进行删除第一个

a = ['a', 'b', 'c', 'a', 'b','b','a']
a.remove("c")
print(a)
a.pop()
print(a)
a.pop(2)
print(a)
del a[0]
print(a)
print(len(a))
del a # 删除全部

5.排序：

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

• 注意sort使用的时候元素的类型要一致

reverse方法是将list逆置。

a = ['a', 'b', 'c', 'a', 'b','b','a']
a.sort()
print(a)
b=[2,1,4,3,6,5,8,7,10,9]
b.sort()
print(b)
b.sort(reverse=True)
print(b)
b.reverse()
print(b)
c=["aac","aaa","aab","abc","aba"]
c.sort()
print(c)
d=[False,True,True,False]
d.sort()
print(d)

---------结果
['a', 'a', 'a', 'b', 'b', 'b', 'c']
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
['aaa', 'aab', 'aac', 'aba', 'abc']
[False, False, True, True]

6.按键值对形式输出列表中元素的下标和值： enumerate()

nameList = ["Mike","Jack","Sarah"]
for i,name in enumerate(nameList):
    print(i,name)
    
0 Mike
1 Jack
2 Sarah

4.3 元组tuple

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

元组的元素不可修改，用（）用作标识。

元素不可变指的是元素的指向不可变，当某个位置的元素指向一个list列表时，不可再指向其他列表，但是这个列表内的元素是可以被改变的。

1.访问

可以用下标来访问元组中元素

tuple=(1,"abcd",True,1.123)
print(tuple)
print(tuple[2])
# 如果要定义一个空的tuple，可以写成()：
t=()
# 定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
t=(1)
# 所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
t=(1,)
# Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

2.修改

python不允许修改元组的数据,包括不能删除其中的元素

t=(123,456,789)
t[1]=188
print(t)

Traceback (most recent call last):
  File "D:/PycharmProjects/PythonTest/com/cw/python/01HelloWorld.py", line 2, in <module>
    t[1]=188
TypeError: 'tuple' object does not support item assignment

3.“可变的”tuple

t = ('a', 'b', ['A', 'B'])
print(t)
t[2][0] = 'X'
t[2][1] = 'Y'
print(t)
--------
('a', 'b', ['A', 'B'])
('a', 'b', ['X', 'Y'])

在元祖中[‘A’,‘B’]存放的是这个列表的地址,它的地址不能修改,但是这个地址指向的列表内容可以进行修改

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

4. 元组的内置函数count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b') 
>>> a.index('a', 1, 3) # 注意是左闭右开区间 
Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: tuple.index(x): x notin tuple 
>>> a.index('a', 1, 4)
 3
>>> a.count('b')
 2
>>> a.count('d') 
0

4.4 字典dict和set

4.4.1 字典的介绍

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

字典中的key不可以重复,如果有重复,覆盖之前的值
value可以重复
value可以为空
set:没有值的dict

dict是一个可变类型

• 字典和列表一样，也能够存储多个数据
• 列表中找某个元素时，是根据下标进行的
• 字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

若访问不存在的键，则会报错

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

dict={"a":100,"b":200,"c":300}
print(dict)
print(type(dict))
print(dict["a"])
print(dict.get("b"))
print(dict.get("d"))  #'d'键不存在，所以d为None
print(dict.get("d",666)) # 若dict中不存在'd'这个键，就返回默认值666

{'a': 100, 'b': 200, 'c': 300}
<class 'dict'>
100
200
None
666

注：通过key获取元素的value时，可能会有key不存在的情况，就就会报错。

​ 还有一种方式可以获取值： 字典名.get(“key”)

​ 这种方式如果key不存在的话不会报错，接收结果的对象为None 空值

4.4.2 字典的常见操作

1. 修改元素：

   字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

   dict["d"] = 400
   print(dict)
   dict["d"] = 600
   print(dict)
   dict["d"] = None
   print(dict)
   
   

2. 添加元素：

   如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素

3. 删除元素

   demo:del删除指定的元素

   info = {'name': '班长', 'sex': 'f', 'address': '地球亚洲中国北京'}
   print('删除前,%s' % info)
   del info['name']
   print('删除后,%s' % info)
   
   

result

删除前,{‘name’: ‘班长’, ‘sex’: ‘f’, ‘address’: ‘地球亚洲中国北京’}
删除后,{‘sex’: ‘f’, ‘address’: ‘地球亚洲中国北京’}

   
   demo:del删除整个字典
   
   ~~~python
   info = {'name':'monitor', 'sex':'f', 'address':'China'}
   print('删除前,%s'%info)
   del info
   print('删除后,%s'%info)
   # result
   删除前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}

demo:clear清空整个字典’

   info = {'name': 'monitor', 'sex': 'f', 'address': 'China'}
   print('清空前,%s' % info)
   info.clear()
   print('清空后,%s' % info)
   # result
   清空前,{'name': 'monitor', 'sex': 'f', 'address': 'China'}
   清空后,{}

4.4.3 字典的常见函数

<1>len()

测量字典中，键值对的个数

<2>keys == map.keySet()

返回一个包含字典所有KEY的列表

<3>values

返回一个包含字典所有value的列表

<4>items

返回一个包含所有（键，值）元祖的列表

<5>has_key （python2.7版本） == in 条件表达式

dict.has_key(key)如果key在字典中，返回True，否则返回False

dict = {"a": 100, "b": 200, "c": 300}
print(len(dict))
print(dict.keys())
print(dict.values())
print(dict.items())
#result
3
dict_keys(['a', 'b', 'c'])
dict_values([100, 200, 300])
dict_items([('a', 100), ('b', 200), ('c', 300)])

4.4.4 字典遍历

dict = {"a": 100, "b": 200, "c": 300}
# 遍历字典的key（键）
for i in dict.keys():
    print(i,dict[i])
# 遍历字典的value（值）
for v in dict.values():
    print(v)
# 遍历字典的项（元素）
for item in dict.items():
    print(item)
# 遍历字典的key-value(键值对)
for i,v in dict.items():
    print(i,v)
    
# result
a 100
b 200
c 300
100
200
300
('a', 100)
('b', 200)
('c', 300)
a 100
b 200
c 300

4.4.5 set

set集合： 无序 唯一

没有value的字典

# 创建set对象：两种方法
d = {1, 2, 3, 4}
print(type(d))
d1 = set([1, 2, 3, 4])  # 该方法创建时,set()中传的参数必须是list列表类型。  
print(d1)  
# 给set添加元素
d1.add(5)
print(d1)

-----------------------
<class 'set'>
{1, 2, 3, 4}
{1, 2, 3, 4, 5}

字典总结

1、请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

2、和list比较，dict有以下几个特点：

1）查找和插入的速度极快，不会随着key的增加而变慢；

2）需要占用大量的内存，内存浪费多。

3）而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

3、dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

4.5 可变类型与不可变类型

1. 可变类型，值可以改变
   • 列表 list
   • 字典 dict
   • set （没有value的字典）
2. 不可变类型，值不可以改变：
   • 数值类型 int, long, bool, float
   • 字符串 str
   • 元组 tuple

五,Python的函数

5.1 函数的定义与调用

1.定义函数

定义函数的格式如下：

def 函数名(): 代码 
    
# 定义一个函数，能够完成打印信息的功能
def printInfo():
	print'------------------------------------'
	print' 人生苦短，我用Python'
	print'------------------------------------'

2.调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用

# 定义完函数后，函数是不会自动执行的，需要调用它才可以 
printInfo()

5.2 函数的参数

1.定义带有参数的函数

def add2num(a, b): 
	c = a+b 
	print c 

2.调用带有参数的函数

def add2num(a, b): 
	c = a+b 
	print c 
add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据

3.带有默认值的参数(缺省参数)

函数在定义时可以指定默认值，在调用时如果传了实参则用实参，如果没有则用默认值。

'''
    函数由四部分组成
    函数名称
    函数体
    函数参数列表
    返回值
1.函数的定义必须要以def开头
2.函数名称+(参数列表)调用
3.函数的参数列表不需要定义类型
4.python的函数没有重载,重名的函数,后面会覆盖前面
5.函数的参数可以带默认值,当调用的时候不指定参数 ,会使用默认值,有参数则覆盖默认值
6.函数调用的时候,可以带有参数名称,此时按照名称进行匹配,不是按照顺序

'''

# 无参的函数
def add():
    print("add")

# 带参数的函数
def add(a,b):
    print(a+b)
# add()  # 会报错,python没有重载的概念,有参数的add已经覆盖掉了无参的add
add(1,2)

# 带默认值参数的函数
def add(a=100,b=200):
    print(a+b)
add(1,2)    # 1+2=3
add()   # 100+200=300 不传参
add(10,) # 10+200=210  只传一个参数

def add(a=100,b=200):
    print(a)
    print(b)
add(b=1,a=2)

运行结果:
3
3
300
210
2
1

注：带有默认值的参数一定要在参数列表的最后面

>>> def	printinfo(name, age=35, sex):
... print name 
... 
File "<stdin>", line 1 SyntaxError: non-default argument follows default argument 

4.不定长(可变)参数

有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

基本语法如下：

def functionname([formal_args,] *args, **kwargs):"函数_文档字符串" 
	function_suite 
	return [expression] 

• 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；
• 加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

# 不定长的参数
'''
    *args:表示一组值的集合,普通数据
    **kwargs:表示k-v格式的数据
'''
def fun(a,b,*args,**kwargs):
    print("a=",a)
    print("b=",b)
    print("*args=",args)
    print("**kwargs=",kwargs)
    for k,v in kwargs.items():
        print(k,v)
fun(1,2,3,4,5,6,7,8,9,10,x=1,y=2)

5.引用传参

可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？

Python有没有类似C语言中的指针传参呢？

list=[1,2,3]
list+=list
print(list)

# 引用传参
a=1
b=[1,2]
def fun(a):
    a+=a
    print("fun 内:",a)
fun(a)  # 值传递
print(a)
fun(b)  # 引用传递
print(b)


运行结果:
[1, 2, 3, 1, 2, 3]
fun 内: 2
1
fun 内: [1, 2, 1, 2]
[1, 2, 1, 2]

Python中函数参数是引用传递（注意不是值传递）。

对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；

而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

5.3 函数返回值

想要在函数中把结果返回给调用者，需要在函数中使用return

return可返回多个值,且返回的值是元组类型。

# 带返回值的函数,可以返回多个返回值
def fun(a,b):
    return a+b,a-b,a*b,a/b
a,b,c,d=fun(100,200)
print(a,b,c,d)
----结果----
300 -100 20000 0.5

注：

1. 如果两次定义的函数的函数名相同，则前面的会被后面的覆盖。
2. 调用函数时，函数有几个参数就必须传几个参数
3. 带有默认值的参数一定要位于参数列表的最后面。

5.4 局部变量和全局变量

1.局部变量

局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。

总结

1. 局部变量，就是在函数内部定义的变量
2. 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
3. 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

2.全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量 定义在函数外。

全局变量可以直接在函数内使用，如果想要修改它的值的话，需要先用globle 对其进行声明。

在方法中不可以修改全局变量的值

'''
1.全局变量可以在方法中使用
2.在方法中不可以改变全局变量的值(加上global可以改变值)
3.不能在global前定义同名的局部变量
'''
count = 100
def fun():
    count = 200
    print(count)
    count = 20
    print(count)
print(count)
fun()
print(count)
# 运行结果
100
200
20
100
-----------------------------------
count = 100
def fun():
    print(count) # 这里会报错,因为这样写count代表全局变量,当count=20时实际改的是全局变量count,它不会认为你定义了一个新的局部变量,然而在方法中不可以改变全局变量的值
    count = 20
    print(count)
print(count)
fun()
print(count)
-----------------
count = 100
def fun():
    count = 200	# 这里会报错,不能在global前定义同名的局部变量
    print(count)
    global count # 声明global后就代表这个变量是一个全局变量,不在和局部变量有关系
    print(count)
    count = 20
    print(count)
print(count)
fun()
print(count)

总结

总结一:

• 在函数外边定义的变量叫做全局变量
• 全局变量能够在所有的函数中进行访问
• 如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
• 如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧：强龙不压地头蛇

总结二:

1. 在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
2. 对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
3. 对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。
4. 可变类型：值可以修改（内存地址不变但是所保存的值变化了），引用可以修改（变量的内存地址变化了）
5. 不可变类型：值不可以修改，可以修改变量的引用（=赋值号）。
6. 在函数里面修改全局变量：
   • 如果全局变量是可变类型：所以在函数里面任意修改（值，引用）
   • 如果全局变量是不可变类型：在函数里面不能修改值，也不能修改引用，除非加上global才能修改引用。
7. 不能在global前定义同名的局部变量

5.5 递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

# 递归函数
'''
    斐波那契数列
    1,1,2,3,5,8,13...
'''
def getNum(a):
    if(a<=2):
        return 1
    else:
        return getNum(a-1)+getNum(a-2)
print(getNum(10))

for i in range(1,11):
    print(getNum(i),end='\t')
    
55
1	1	2	3	5	8	13	21	34	55	

5.6 匿名函数

1.匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:
	expression 

例子

# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2  # 调用sum函数
print("Value of total : ", sum(10, 20))
print("Value of total : ", sum(20, 20))


Value of total :  30
Value of total :  40

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数不能直接调用print，因为lambda需要一个表达式

2.应用场合

'''
用途
    1.当做函数的参数
    2.当作内置参数使用
'''
# 当做函数的参数
def fun(a, b, opt):
    print("a=", a)
    print("b=", b)
    print("result=", opt(a, b))


fun(1, 2, lambda a, b: a + b)
fun(1, 2, lambda a, b: a - b)
fun(1, 2, lambda a, b: a * b)
fun(1, 2, lambda a, b: a / b)

# 当作内置参数使用
stus = [{"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 19}, {"name": "wangwu", "age": 17}]
print(stus)
stus.sort(key=lambda x: x['name'])
print("按name排序:", stus)
stus.sort(key=lambda x: x['age'])
print("按age排序:", stus)

# 运行结果
a= 1
b= 2
result= 3
a= 1
b= 2
result= -1
a= 1
b= 2
result= 2
a= 1
b= 2
result= 0.5
[{'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}]
按name排序: [{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]
按age排序: [{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]

小程序:计算器的实现

'''
写一个计算器程序：用循环封装，从控制台输入数据和运算符，能够从控制台退出。
'''

# 进行运算的函数
def operator(num1, num2, opt):
    num1 = int(num1)
    num2 = int(num2)
    if (opt == "+"):
        return num1 + num2
    elif (opt == "-"):
        return num1 - num2
    elif (opt == "*"):
        return num1 * num2
    elif (opt == "/"):
        return num1 / num2

# 判断数据是否符合要求
def judgeNum(num, id):
    if (num == "q"):
        return False
    elif (num.isdigit() == False):
        while (True):
            print("输入错误!请重新输入第[", id, "]位数据")
            num = input("请输入数据:")
            if (num.isdigit()):
                break
            elif (num == "q"):
                return False
    return num

# 判断操作符是否符合要求
def judgeOpt(opt):
    if (opt not in ["+", "-", "*", "/"]):
        while (True):
            print("操作符不符合要求,应为:[+,-,*,/]中的一个")
            opt = input("请重新输入操作符:")
            if (opt in ["+", "-", "*", "/"]):
                return opt
    else:
        return opt


while (True):
    n1 = input("请输入数据1:")
    n1 = judgeNum(n1, 1)
    if (n1 == False):
        break
    n2 = input("请输入数据2:")
    n2 = judgeNum(n2, 2)
    if (n2 == False):
        break
    opt = input("请输入操作符:")
    opt = judgeOpt(opt)
    result = operator(n1, n2, opt)
    print("%s%s%s=%s" % (n1, opt, n2, result));

六,Python的文件操作

6.1 文件的打开与关闭

想一想：如果想用word编写一份简历，应该有哪些流程呢？

1、打开word软件，新建一个word文件

2、写入个人简历信息

3、保存文件

4、关闭word软件

同样，在操作文件的整体过程与使用word编写一份简历的过程是很相似的 （io操作）

1、打开文件，或者新建立一个文件

2、读/写数据

3、关闭文件

1.打开文件

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件

open(文件名，访问模式)

open默认模式是r只读模式

f = open(r'd:\nata\test.txt', 'w')  r:标志在后面的均为普通字符

访问模式说明:

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于**追加**。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2.关闭文件

close( )

示例如下：

# 新建一个文件，文件名为:
test.txt f = open('test.txt', 'w') # 关闭这个文件 
f.close()

6.2 文件的读写

1.写数据(write)

使用write()可以完成向文件写入数据

# 写(如果存在则覆盖,不存在文件则创建文件再写入)
f=open("d://wc.txt","w")
f.write("abc")
f.close()

# 写(如果存在则追加,不存在文件则创建文件再写入)
f=open("d://wc.txt","a")
f.write("abc")
f.close()

2.文件的读写

1.read

read(int num) 指定文件读取的字节数

使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

f = open('test.txt', 'r') 
content = f.read(1024) 
print(content) 
print("-"*30) 
content = f.read() 
print(content) 
f.close() 

注意：如果open是打开一个文件，那么可以不用写打开的模式，即只写 open(‘test.txt’)，如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的

2.readline

只读取一行文件内容

#coding=utf-8 
f = open('test.txt', 'r') 
content = f.readline() 
print("1:%s"%content) 
content = f.readline() 
print("2:%s"%content) 
f.close() 

3.readlines

就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

#coding=utf-8 
f = open('test.txt', 'r') 
content = f.readlines() 
print(type(content)) 
i=1
for temp in content: 
print("%d:%s"%(i, temp)) 
i+=1 
f.close() 

区别

f=open("d://wc.txt")
# 读取所有文件内容
# content=f.read()
# 读取一行文件内容
# content=f.readline()
# 读取多行文件内容\
content=f.readlines()
for i in content:
    print(i)
f.close()

6.3 文件的定位读写

1.获取当前读写的位置tell

在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取

wc.txt
abc hello world
hive hbase spark
python hadoop scala
impala

# 获取文件读取的位置
f=open("d://wc.txt")
print(f.readline())
print(f.tell())
f.close()
运行结果为:
abc hello world

17   # abc hello world共15个字节, 换行符\n两个字节


# 打开一个已经存在的文件
f = open("d://wc.txt", "r")
str = f.read(3)
print("读取的数据是 : ", str)
# 查找当前位置
position = f.tell() 
print("当前文件位置 : ", position)
str = f.read(3)
print("读取的数据是 : ", str)
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
f.close()

读取的数据是 :  abc
当前文件位置 :  3
读取的数据是 :   he
当前文件位置 :  6

2.定位到某个位置

如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()

seek(offset, from)有2个参数

• offset:偏移量
• from:方向
  • 0:表示文件开头
  • 1:表示当前位置
  • 2:表示文件末尾

abc hello world
hive hbase spark
python hadoop scala
impala

f = open("d://wc.txt", "r")
f.seek(5,0)
print(f.readline())	# ello world
f.close()


demo:把位置设置为：从文件开头，偏移5个字节
# 打开一个已经存在的文件 
f = open("d://wc.txt", "r") 
str = f.read(30) 
print("读取的数据是 : ", str) 
# 查找当前位置 
position = f.tell() 
print("当前文件位置 : ", position) 
# 重新设置位置 
f.seek(5,0) 
# 查找当前位置 
position = f.tell() 
print("当前文件位置 : ", position)
f.close() 
# 运行结果
读取的数据是 :  abc hello world
hive hbase spa
当前文件位置 :  31
当前文件位置 :  5


demo:把位置设置为：离文件末尾，3字节处
# 打开一个已经存在的文件
f = open("d://wc.txt", "rb")
# 查找当前位置
position = f.tell()
print("当前文件位置 : ", position)
# 重新设置位置
f.seek(-3,2)
# 读取到的数据为：文件最后3个字节数据
str = f.read()
print("读取的数据是 : ", str)
f.close()

# 运行结果
当前文件位置 :  0
读取的数据是 :  b'ala'

6.4 文件的相关操作

有些时候，需要对文件进行重命名、删除等操作，python的os模块中都有这么功能

import os

python编程时，经常和文件、目录打交道，这是就离不了os模块。os模块包含普遍的操作系统功能，与具体的平台无关。以下列举常用的命令

1. os.name()——判断现在正在使用的平台，Windows 返回 ‘nt’; Linux 返回’posix’
   rename(需要修改的文件名, 新的文件名) 也可以做剪切。

2. os.getcwd()——得到当前工作的目录。

3. os.listdir()——指定所有目录下所有的文件和目录名。

   以列表的形式全部列举出来，其中没有区分目录和文件。

4. os.remove()——删除指定文件

5. os.rmdir()——删除指定目录 ：该目录不能为空

6. os.mkdir()——创建目录
   注意：这样只能建立一层，要想递归建立可用：os.makedirs(x/y/z)

7. os.path.isfile()——判断指定对象是否为文件。是返回True,否则False

8. os.path.isdir()——判断指定对象是否为目录。是True,否则False。例：

9. os.path.exists()——检验指定的对象是否存在。是True,否则False.例：

10. os.path.split()——返回路径的目录和文件名。例：
    

11. os.getcwd()——获得当前工作的目录（get current work dir)

12. os.system()——执行shell命令。例：

**注意**：此处运行shell命令时，如果要调用python之前的变量，可以用如下方式：

```shell
var=123
os.environ['var']=str(var) //注意此处[]内得是 “字符串” 
os.system('echo $var')

```

13. os.chdir()——改变目录到指定目录

14. os.path.getsize()——获得文件的大小，如果为目录，返回0

15. os.path.abspath()——获得绝对路径。例：

16. os.path.join(path, name)——连接目录和文件名。例：

17. os.path.basename(path)——返回文件名

18. os.path.dirname(path)——返回文件所在目录

import os
print(os.name)
print(os.listdir())
print(os.getcwd())
# os.remove("d://wc.txt")
# os.mkdir("d://abc")

print(os.path.isfile("d://abc"))
print(os.path.isdir("d://abc"))

os.system("echo 'java -version'")
os.system("java -version")
os.system("dir")

6.5 路径补充

f=open("d:\wc.txt","w") # 适用于windows和linux
f.write("python")
f.close()

f=open("d://wc.txt","w") # 只适用于windows
f.write("python")
f.close()

f=open("d:\test.txt","w") # 这样写程序会认为\t是制表符
f.write("python")
f.close()
# 解决以上问题,有两种方法
f=open("d:\\test.txt","w") # 遇到转义字符可以多加一个\
f.write("python")
f.close()

f=open(r"d:\test.txt","w") # 在路径前加一个r:表示""内的字符表示其本身自己的含义
f.write("python")
f.close()