Python知识与操作:

01. 头文件申明:

#!/usr/bin/env python

# -*- coding:utf8 -*-

Linux中shell执行python程序，头部需要加解释器路径

在python2执行的py文件有中文时，头部需要指定那个编码解释

02. python解释执行器:

python（python2的解执执行器)

python3

03. python解执行器的交互模式:

$ python3 <回车> # 进入交互模式

退出交互模式:

>>> exit() <回车>

>>> quit() <回车>

输入 ctrl + d (输入文件结束符)

04. python注释:

单行注释: # 开头, 直至行尾

多行注释:''' 被注释的内容 ''', """这个也是多⾏行行注释"""

作用: 让注释内容不参加解释执行

05. python程序的组成:

程序由模块组成

模块由语句，函数，类等组成

语句包含表达式

表达式建立并处理数据对象且能返回数据对象的引用关系

06. python中自动化内存管理和引用计数:

每个对象都会记录有几个变量引用自身，当引用的数量为0时，则此对象将被销毁

a = 1000

b = 2000

a = a + b

c = a # a 和 c 同时绑定在3000上

07. python 关联/绑定/引用的含义:

关联/绑定/引用都是指变量和一个对象的关联关系

python中变量没有类型

变量示例:

# abc 三个变量同时绑定同一个对象30000

a = b = c = 10000 + 20000

a = 1

b = 2

c = 3

# 以上三行可以写为如下：

a, b, c = 1, 2, 3

a, b, c = [1, 2, 3]

a, b, c = (1, 2, 3)

08. 小数据池(常量池):

CPython中把我们使用过的值存储在小数据池中, 供其他的变量使用

小数据池给数字和字符串使用, 其他数据类型不存在

对于数字: -5~256是会被加到小数据池中的. 每次使用都是同一个对象

对于字符串:

01. 如果是纯文字信息和下划线,那么这个对象会被添加到小数据池

02. 如果是带有特殊字符的. 那么不会被添加到⼩小数据池. 每次都是新的

03. 如果是单一字母*n的情况,'a'*20,在20个单位内是可以的,超过20个单位就不会添加到小数据池中

注意(一般情况下):

在py文件中,如果你只是单纯的定义一个字符串,那么一般情况下都是会被添加到小数据池中

在使用字符串的时候,python会帮我们把字符串进行缓存,在下次使用的时候直接指向这个字符串即可

可以节省很多内存.

09. 编码:

ASCII 8位 1个字节(byte)

GBK 国标码 16位 2个字节(双字节字符)

unicode 万国码 32位 4个字节

utf-8 英文 8位 1个字节, 欧洲文字 16bit 2个字节, 中文 24bit 3个字节

注: python3中,内存中使用的是unicode码.

单位转换:

8bit = 1byte 8位 = 1字节

1024byte = 1KB 1024字节 = 1千字节

1024KB = 1MB 1024千字节 = 1兆字节-->百万字节

1024MB = 1GB 1024兆字节 = 1吉字节-->十亿字节

1024GB = 1TB 1024吉字节 = 1太字节-->万亿字节

1024TB = 1PB 1024太字节 = 1拍字节-->千万亿字节

1024PB = 1EB 1024拍字节 = 1艾字节-->百亿亿字节

1024EB = 1ZB 1024艾字节 = 1泽字节-->十万亿亿字节

1024ZB = 1YB 1024泽字节 = 1尧字节-->一亿亿亿字节

10. 解构(解包)

dic = {"id": 123, "name": 'Coco', "age": 18}

for key, value in dic.items(): # 解构

print(key, value)

a, b = 1, 2 # 解构

11. python项目的命名规则:

01. 项目名前面都以数字编号-->编号递增

02. 项目下的文件名都以xx_xx_xx方式命名

03. 命名文件名时建议使用小写字母数字下划线

04. 文件名不能以数字开始

12. .pyc文件:

01. 浏览项目目录会有一个__pycache__的目录

02. 目录下会有一个xxx.cpython-37.pyc文件，cpython-37表示Python解释器的版本

03. 这个pyc文件是由Python解释器将模块的源码转换为字节码, 这样保存字节码是作为一种启动速度的优化

04. Python在解释源程序时分成两个步骤:

01. 首先处理源代码, 编译生成一个二进制字节码

02. 再对字节码进行处理, 才会生成CPU能够识别的机器码

05. 有了模块的字节码文件之后, 下一次运行程序时, 如果在上次保存字节码之后没有修改过源代码, Python将会加载.pyc文件并跳过编译这个步骤

06. 当Python 重编译时, 它会自动检查源文件和字节码文件的时间戳

07. 如果修改了源代码, 下次程序运行时, 字节码将自动重新创建

Python的基础语法:

01. 表达式 expression:

由数字或数字和运算符组成

01. 通常是让计算机做一些事情并返回结果:

示意:

1 + 2

1 + 2 * 3

02. 括号分组子表达式:

用() 可以将表达式分组,()内部的表达式先进行计算

03. 混合类型自动升级:

1 + 2.14 # 返回类型为浮点型 3.14

02. 运算符:

01. 算术运算符:

+ 加法:

10 + 10 # 得 20

- 减法:

20 - 10 # 得 10

* 乘法:

10 * 10 # 得 100

/ 除法:

python 的除法不会丢掉小数部分

1 / 3 # 得 0.33333333

// 地板除(floordiv):

7 / 3 # 得 2.3333333

7 // 3 # 得 2

3.25 // 1.5 # 得 2.0

% 求余:

7 % 3 # 得 1

3.25 % 1.5 # 得 0.25

** 幂运算:

x ** y # 意为 x的y次方

5 ** 2 # 得 25

3.0 ** 2.0 # 得 9.0

算术运算符的优先级:

** (高)

* / // % (中)

+ - (相对较低)

02. 身份运算符(is / is not )

is:

判断两个对象是否是同一个对象，如果是同一样对象，返回True,否则返回False

is not:

与is相反

语法:

x is y

x is not y

03. 复合赋值算术运算符:

y += x 等同于 y = y + x

y -= x 等同于 y = y - x

y *= x 等同于 y = y * x

y /= x 等同于 y = y / x

y //= x 等同于 y = y // x

y %= x 等同于 y = y % x

y **= x 等同于 y = y ** x

04. 比较运算符:

< 小于

<= 小于等于

> 大于

>= 大于等于

== 等于

!= 不等于

语法:

左表达式 < 右表达式

说明：

比较运算符返回布尔类型的值

05. 布尔(逻辑)运算符:

运算符:not and or

01. 布尔非操作 not:

语法:

not x

作用：

对 x 进行布尔取非，如bool(x) 为True则返回False, 否则返回True

02. 布尔与操作 and:

语法:

x and y

注: x, y代表表达式

作用：

　　 优先返回假值对象，当x的布尔值为False时，返回x,否则返回y

示意:

True and True # 返回True

True and False # 返回False

False and True # 返回False

False and False # 返回False

示例:

x = int(input("请输入一个月份:"))

if 1 <= x <= 12: # if 1 <= x and x <= 12:

print("合法的月份")

if gender == "男" and age < 50:

print("可以面试")

03.布尔或运算 or

语法:

x or y #等同于x if bool(x)==True else y

作用：

优先返回真值对象

当 x为True时，返回 x, 否则返回y

示意:

True or True # True

True or False # True

Flase or True # True

Flase or False # False

示例1:

x = int(input("请输入一个月份:"))

if x < 1 or x > 12:

print("您输入的有错!")

示例2:

s = input("请输入学生成绩: ") or '0' # 加or作用避免空字符串时报错

score = int(s) # int不可转换空字符串为整型

04. 布尔(逻辑)运算符优先级:

在没有()的情况下not 优先级高于 and，and优先级高于or，同一优先级从左往右计算

优先级顺序: () ==> not ==> and ==> or

06. 正负号运算符:

+ (正号) -(负号)

语法:

+ 表达式

- 表达式

注：正负号运算符是一元运算符(只有一个元素参加运算)

示例:

a = 5

b = -a

c = +a

d = (2-3j)

e = -d # (-2+3j)

07. 成员运算符(in / not in)

if a in [1, 2, 3]:

print("a在列表中") # a在列表中

for i in range(10):

print(i, end=" ") # 0 1 2 3 4 5 6 7 8 9

if "e" not in 'abede':

print("ok")

else:

print("error") # error

08. 位运算符:

按位运算符是把数字看作二进制来进行计算

& 按位与运算符:

参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

(a & b) 输出结果 12 ，二进制解释： 0000 1100

| 按位或运算符:

只要对应的二个二进位有一个为1时，结果位就为1

(a | b) 输出结果 61 ，二进制解释： 0011 1101

^ 按位异或运算符:

当两对应的二进位相异时，结果为1

(a ^ b) 输出结果 49 ，二进制解释： 0011 0001

~ 按位取反运算符:

对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1

(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式

<< 左移动运算符:

运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0

a << 2 输出结果 240 ，二进制解释： 1111 0000

>> 右移动运算符:

把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

a >> 2 输出结果 15 ，二进制解释： 0000 1111

示例:

a = 60 # 60 = 0011 1100

b = 13 # 13 = 0000 1101

c = 0

c = a & b; # 12 = 0000 1100

print "1 - c 的值为：", c

c = a | b; # 61 = 0011 1101

print "2 - c 的值为：", c

c = a ^ b; # 49 = 0011 0001

print "3 - c 的值为：", c

c = ~a; # -61 = 1100 0011

print "4 - c 的值为：", c

c = a << 2; # 240 = 1111 0000

print "5 - c 的值为：", c

c = a >> 2; # 15 = 0000 1111

print "6 - c 的值为：", c

09. 运算符优先级总结:

逻辑运算符 and or not 优先级小于比较运算符 > >= < <= == !=

比较运算符 > >= < <= == != 优先级小于算数运算符 + - * / // % **

正负号运算符+(正号) -(负号) 优先级仅次于**

03.变量:

定义:变量是关联一个对象的标识符(符号)

作用：用来绑定一个数据对象，以便于以后重复使用

01. 变量名的命名方法:

01. 变量名必须为字母(a-zA-Z)或下划线(_)开头，后跟字母，下划线或数字(0-9)

02. 不能使用python的关键字(保留字)

03. 变量名区分大小写, 命名要有意义, 见名知意

04. 驼峰和下划线命名:

01. 小驼峰 第一个单词以小写单词开始, 后续单词首字母大写:

例如 fileName listName

02. 大驼峰 每一个单词的首字母都采用大写字母:

例如 FileName ListName

03. 下划线 单词与单词之间使用 _下划线 连接:

例如 file_name list_name

05. python中变量尽命名量不要使用驼峰命名法

02. python变量名区分大小写:

01. 合法的变量名: a a1 b bbb _aaaa __ABCD var get_value AbCd abcd

02. 不合法的变量名: 1a 123 $ABC +a -b ### @ABC a1& a#b

03. 在交互模式下，查看当前作用域内变量的方法:

>>> help("__main__")

退出键: q

04. 变量的引用:

01. 变量和数据都是保存在内存中且分开存储的

02. 数据保存在内存中的一个位置

03. 变量中保存着数据在内存中的地址

04. 变量中记录数据的地址叫做引用

05. 使用id()函数可以查看变量中保存数据所在的内存地址

06. 从新给一个变量赋值本质是修改了数据的引用

07. 局部变量(local):

01. 局部变量是在函数内部定义的变量, 在函数执行时才会创建且只能在函数内部使用

02. 函数执行结束后, 函数内部的局部变量会被系统回收

03. 不用的函数可以定义相同名字的局部变量, 彼此之间不会产生影响

示例:

def demo1():

# 定义一个局部变量

# 在函数内部定义的变量，不能在其他位置使用

num = 10

print("在demo1函数内部的变量是 %d" % num)

def demo2():

num = 11

print("在demo2函数内部的变量是 %d" % num)

demo1()

demo2()

08. 全局变量(global):

01. 全局变量是在函数外部定义的变量, 所有的函数都可以使用

02. 不允许直接修改全局变量的值, 希望修改全局变量的值, 使用 global 声明一下全局变量

03. 在开发时，应该把模块中的所有全局变量定义在所有函数的上方, 以保证所有函数都可以正常访问每一个全局变量

示例:

# 全局变量

num = 10

def demo1():

# 在python中，不允许直接修改全局变量的值

# 如果使用赋值语句，会在函数内部定义一个局部变量

num = 12

print("demo1 ==> %d" % num)

def demo2():

# 希望修改全局变量的值 - 使用 global 声明一下全局变量即可

# global 关键字后面的变量会声明一个全局变量

global num

print("demo2 ==> %d" % num)

demo1()

demo2()

04. = 赋值语句(statement):

01. 语法:

变量名 = 表达式

变量名1 = 变量名2 = 表达式

变量名1, 变量名2, ... = 序列

02. 作用：

用于将一个变量绑定（或关联)在一个对象上

03. 说明：

1. 当变量不存在时，创建该变量，并绑定这个对象

2. 当变量存在时，改变这个变量的绑定关系

3. 一个变量只能绑定一个对象

4. 两个变量可以同时绑定同一个对象

04. 示例：

print(3.1415926 * 10 * 2) # 求半径为10的圆的周长

pi = 3.1415926

print(pi * 20 * 2)

05. del 语句(delete):

作用:用于删除变量，同时解除与对象的关联关系，如果可能，则释放对象

语法:del 变量名

06. 基本输出函数 print

格式:

print(要打印的东西)

示例1:

print("hello")

print(1 + 2 * 3)

# 多个数据打印时用逗号分隔开

print(1 + 2, 3 + 4, 100)

等同于

print(3, 7, 100)

示例2:

print(value, ..., sep=' ', end='\n')

关键字参数说明:

sep: 两个值之间的分隔符,默认为一个字格' '

end: 输出完毕后在流末尾自动追加一个字符串，默认为换行符'\n'

07. id 函数:

作用：

返回一个对象在内存中的地址

用法:

id(x)

08. 数值对象的构造(创建)函数:

float(obj) 用字符串或数字转换为浮点数

int(x='0', base=10) 用数字或字符串转换为整数，如果不给出参数，则返回0

complex(r=0.0, i=0.0) 用数字创建一个复数(实部为r,虚部为i)

bool(x) 用x创建一个布尔值(True/False)

09. 函数调用:

函数名(传参列表)

说明:

函数调用是表达式，通常用于返回一个对象的引用关系

10. 预置(内建)的数值型函数:

abs(x) 取x的绝对值

round(number, ndigits) 对数值进行四舍五入, ndigits 是小数向右取整数的位数，负数表示向左取整

pow(x, y, z=None) 相当于 x**y 或 x**y%z

help(function): 查看函数的帮助, help(abs) 查看abs函数的帮助文档

11. 折行符 \ (反斜杠):

折行符是告诉解释执行器, 下一行的内容也是此语句的内容

PEP8明确指定了一行代码的长度不要超过79个字符

12. 隐式换行:

所有的括号的内容换行时, 解释执行器会自动去下一行找到相对应的括号, 直到找到为止, 称作隐式换行

13. 基本输入函数(input):

作用：

从标准输入设备上读取一个字符串

(注: 末尾的换行字符会被删除)

格式:

input('提示字符串')

注：返回一个字符串, 提示字符串可以为空

14. if 语句:

作用:

让程序根据条件选择性的执行某条语句或某些语句

语法:

if 真值表达式1:

语句块1...

elif 真值表达式2:

语句块2...

elif 真值表达式3:

语句块3...

...

else:

　语句块4...

说明:

01. 真值判断会自上而下进行:

如果有一条为True则执行其中的语句，然后结果if语句的执行,

如果所有真值表达式都为False,则执行else子句里的语句

02. elif 子句可以有0个，１个或多个

03. else 子句可以有0个或１个

15. if 条件表达式(三元表达式):

语法：

表达式1 if 真值表达式 else 表达式2

作用：

如果直值表达式的布尔值为True时，则执行达式1 并返回结果对象的引用， 否则执行表达式2 并返回对象的引用

示例1:

money = int(input("请输入商品金额")) # 输入50-->50 输入100-->80

pay = money - 20 if money >= 100 else money

print("您需要支付:", pay, "元")

示例2:

name = "coco"

res = "嗨" if name == "coco" else "嗨嗨"

print(res)

16. pass 语句:

作用:

通常用来填充语法空白

示例:

def add(x, y):

pass

17. 常用的序列函数:

len(x) 返回序列的长度

max(x) 返回序列的最大值的元素

min(x) 返回序列的最小值的元素

sum(x) 返回序列中所有元素的和(元素必须是数值类型)

any(x) 真值测试, 如果容器内其中一个值为True则返回True,否则返回False

all(x) 真值测试, 容器内所有元素的布尔值为True才返回True

str(object) 将对象序列化为字符串

list(iterable) 将可迭代对象序列化为列表

tuple(iterable) 将可迭代对象序列化为元祖

reversed(seq) 返回反向顺序的迭代器对象

sorted(iterable, reverse=False) 返回已排序的列表

例如:

sorted('a' 'b', reverse=True) # ['b', 'a']

sorted('bca', reverse=False) # ['a', 'b', 'c']

18. 字符串编码转换函数:

ord(c) 返回一个字符的Unicode值

chr(i) 返回i这个值所对应的字符

示例:

i = ord('唐')

print(i) # 21776

c = chr(21776)

print(c) # 唐

19. 整数传换为字符串函数:

hex(i) 将整数转换为 十六进制字符串 hex(15) # '0xf'

oct(i) 将整数转换为 八进制字符串 oct(7) # '0o7'

bin(i) 将整数转换为 二进制字符串 bin(3) # '0b11'

20. 字符串构造函数:

str(obj='') 将对象转换为字符串 str(123) # '123'

21. while 语句(循环语句):

作用：

根据一定条件，重复的执行一条语句或多条语句

语法:

while 真值表达式:

语句块1...

else:

语句块2

说明:

01. 先执行真值表达式,测试布尔值为 True 或 False

02. 如果真值表达式的测试值为True,则执行语句1,然后再返回到第1步重复进行测试

03. 如果真值表达式的测试值为False,则执行else子句中的语句块2,然后结束此while语句的执行。如果没有else子句，则直接结束while语句的执行

04. else子句部分可以省略(同if语句类似)

while 语句的注意事项:

01. 要控制循环的真值表达式的值来防止死循环

02. 通常用真值表达式中的循环变量来控制循环条件

03. 通常在循环语句块内需要改变循环变量来控制循环的次数和变量的走向

while 语句嵌套:

while语句本身是语句，和其它语句一样可以嵌套在其它复合语句中(如:if语句，while语句，for语句...的内部)

while 语句嵌套示意:

while 真值表达式:

....

while 真值表达式2:

....

else:

....

else:

.... # 当条件为假的时候执行,break跳出循环不执行else部分

22. break 语句(跳出循环):

作用：

用于循环语句(while, for语句)中,用来终止当前循环语句的执行

说明：

01. 当break语句执行后，此循环语句break之后的语句将不再执行

02. break语句通常和if语句组合使用

03. break语句终止循环时，循环语句的else子句将不会被执行

04. break语句只能终止当前循环的执行，如果有循环嵌套时，不会跳出嵌套的外重循环

05. break 语句只能在循环语句(while或 for语句)内部使用

23. 死循环 death loop:

01. 死循环是指循环条件一直成立的循环

02. 死循环通常用break语句来终止循环

03. 死循环的else子句永远不会执行

24.for 语句(循环语句)

作用：

用来遍历可迭代对象的数据元素

语法:

for 变量列表 in 可迭代对象:

语句块1 ...

else:

语句块2 ...

语法说明：

01. 可迭代对象每次提供一个元素依次赋值给变量列表中的变量,赋值完毕后执行语句块1,重复执行此步骤

02. 当可迭代对象不能够提供数据时，执行else子句部分的语句块2. 然后退出循环

03. else子句部分可以省略(同while语句类似)

04. 当在语句内部用break终止循环时，else子句部分语句块2不会执行.

25. range函数:

作用：

用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)

调用格式:

range(stop) 从零开始，每次生成一个整数后加1操作,直到stop为止(不包含stop)

range(start, stop, step) 从start开始，每次生成一个整数后移动step,直到stop为止（不包含stop,且step可以为负整数

示例：

range(4) # 生成 0 1 2 3

range(3, 6) # 生成 3 4 5

range(1, 10, 2) # 生成 1 3 5 7 9

range(5, 0, -2) # 生成 5 3 1

range(4, 1) # 空

26. continue 语句

作用：

用于循环语句(while,for语句)中,不再执行本次循环内continue之后的语句，重新开始一次新的循环

说明:

01. 在while语句中执行 continue语句，将直接跳转到while语句的真值表达式处重新判断循环条件

02. 在for语句中执行continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次进行循环

27. 不拷贝(赋值), 浅拷贝 shallow copy 和 深拷贝 deepcopy:

不拷贝(赋值):

列表进行赋值操作时实际上是引用内存地址的赋值

list1 = [1, 2, 3, 4]

list2 = list1 # 此时内存中只有一个列表,两个变量指向一个列表

list2.append(5) # 对其中一个列表操作,另一个列表也跟着改变

print(list1) # [1, 2, 3, 4, 5]

print(list2) # [1, 2, 3, 4, 5]

浅拷贝 copy:

是指复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程

示例:

L = [3.1, 3.2]

L1 = [1, 2, L] #[1, 2, [3.1, 3.2]]

L2 = L1.copy() #[1, 2, [3.1, 3.2]]浅拷贝

L[0] = 3.14

L1 # [1, 2, [3.14, 3.2]]

L2 # [1, 2, [3.14, 3.2]]

# L1[2] 和 L2[2] 共同拥有 L绑定的对象

a = [1, 2]

a[1] = a

print(a[1]) # [1, [...]]

深拷贝 deepcopy:

拷贝所有层级

示例:

import copy # 导放copy模块

L = [3.1, 3.2]

L1 = [1, 2, L] #[1, 2, [3.1, 3.2]]

L2 = copy.deepcopy(L1) # 深拷贝

L[0] = 3.14

L1 # [1, 2, [3.14, 3.2]]

L2 # [1, 2, [3.1, 3.2]] 此列表不受影响

注：深拷贝通常只对可变对象进行深层复制，不可变对象通常不会被复制

28. 常量:

全部字母大写常量. 约定俗成

例如: PI = 3.141592653

注: 在python中不存在绝对的常量

Python的33个关键字:

python3的33个关键字:

False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield

assert else import pass break

except in raise

01. False:

布尔类型的值，表示假

None/空字符串/空元组/空列表/空字典/空集合/0 真值都是False

None str() tuple() list() dict() set() int() # 真值都是False

None "" () [] {} set() 0 # 真值都是False

02. class:

定义类的关键字

例如:

class Cat:

"""定义一个猫类"""

pass

tom_obj = Cat() # 实例化一个猫对象tom_obj

03. finally:

异常处理使用的关键字, 与try连用, finally里面的代码无论如何始终会被执行

例如:

try:

age = int(input("请输入年龄:"))

finally:

print("无论什么情况都会执行我")

04. is:

Python中的对象包含三个要素：id, type, value

id:用来唯一标示一个对象

type：标识对象的类型

value：是对象的值

is：就是用来判断a对象是否就是b对象, 是通过id来判断的

==：判断的是a对象的值是否和b对象的值相等, 是通过value来判断的

例如：

>>> a = 1

>>> b = 1.0

>>> a is b

False

>>> a == b

True

>>> id(a)

8791440405328

>>> id(b)

75766808

05. return:

函数返回值return, 如果没有定义函数返回值, 那么会得到一个结果是None对象, 而None表示没有任何值, 即空值

例如：

def fnc1(x,y):

print x+y

>>> result = fnc1(2, 3)

>>> result is None

True

06. None:

None是一个特殊的常量, None和False不同, None不是0, None不是空字符串

None和任何其他数据类型比较永远返回False, None有自己的数据类型NoneType

可以将None复制给任何变量, 但是不能创建其他NoneType对象

例如：

>>> type(None)

<class 'NoneType'>

>>> None == 0

False

>>> None == ''

False

>>> None == None

True

>>> None == False

False

07. continue:

continue语句被用来告诉Python跳过当前循环块中的剩余语句, 然后继续进行下一轮循环

例如:

j = 0

for i in range(5):

if i == 3:

continue # 当i = 3时,跳过j += i 进入下一论循环

j += i

print(j) # 7

08. for:

for循环可以遍历任何序列的项目, 如一个字符串或者一个列表

例如：

for letter in 'Python': # 第一个实例

print("当前字母:%s" % letter)

lst = ["coco", "cat", "cc"]

for temp in lst: # 第二个实例

print(temp)

09. lambda:

匿名函数, 函数式编程风格, 提升了代码的简洁程度。

例如：

g = lambda x:x+1

g(1)

>>>2

g(2)

>>>3

g(7)

>>>8

再例如：

>>> lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>res = filter(lambda x: x % 2 == 0, lst)

>>>list(res)

[2, 4, 6, 8, 10]

>>>

>>>list(map(lambda x: x * 2 + 10, lst))

[12, 14, 16, 18, 20, 22, 24, 26, 28, 30]

>>>

>>>from functools import reduce

>>>reduce(lambda x, y: x+y, lst)

55

10. try:

使用try…except语句来处理异常。把通常的语句块放在try块中,而把错误处理的语句放在except块中

例如:

try:

# 提示用户输入一个整数

num = int(input("请输入一个整数："))

# 使用8除以用户输入的整数并且输出

print("8除以 %d 结果是：%.2f" % (num, 8 / num))

except ValueError:

print("请输入正确的整数")

except Exception as result:

print("未知错误：%s" % result)

else:

print("尝试成功")

finally:

print("无论是否出现错误都会执行的代码")

11. true:

布尔类型的值, 表示真, 与false相反

非0为真

12. def:

定义函数

例如：

def hello():

print('hello,hongten')

# 调用函数

hello() # hello,hongten

13. from:

在python用import或者from…import来导入相应的模块

from sys import path # 导入sys模块中的环境变量path

print(path)

14. nonlocal:

nonlocal关键字用来在函数或其他作用域中使用外层（非全局）变量

例如：

def make_counter():

count = 0

def counter():

nonlocal count

count += 1

return count

return counter

ret = make_counter()

print(ret()) # 1

15. while:

while语句重复执行一块语句, while是循环语句的一种, while语句有一个可选的else从句

while 1的效率比 while True 稍微高一点点

例如:

i = 0

count = 0

while i <= 100:

if i == 50:

i += 1

break # 彻底停止循环. 不会执行后面的else

count += i

i += 1

else: # while条件不成立的时候执行

print("正常循环条件不满足退出循环时执行else从句, 循环内容break时不会执行到else从句")

print(count)

16. and:

逻辑判断语句, and左右两边都为真, 则判断结果为真, 否则都是假

1 and 5 # 5 左边为真时, 返回右边的值

0 and 5 # 0 左边为假时, 返回左边的值

17. del:

常用于列表操作, 删除一个或者连续几个元素

例如：

a = [-1,3,'aa',85] # 定义一个list

del a[0] # 删除第0个元素

del a[2:4] # 删除从第2个到第3个元素

18. global:

定义全局变量(声明局部作用域的变量为全局变量)

num = 0

def nums():

global num

num += 1

nums()

print(num) # 1

19. not:

逻辑判断，取反的意思

lst = []

if not lst: # lst真值为假, not取反为真, 则if成立

print("空列表")

20. with:

with可以用来简化try…finally语句, 它的主要用法是实现一个类_enter_()和_exit_()方法

例如：

class A:

def __init__(self):

print('init')

def __enter__(self):

print('before')

def __exit__(self, exc_type, exc_val, exc_tb):

print('after')

with A() as a:

print('123')

执行结果:

init

before

123

after

21. as:

结合with使用, 常用于打开文件操作

with open("文件名.txt" "w") as f:

f.write("hello world")

22. elif:

和if配合使用

choice = input("请输入数字(0-2):")

if choice == '0':

quit()

elif choice == '1':

print("查询")

elif choice == '2':

print("修改")

else:

print("输入有误")

23. if:

if语句用来检验一个条件, 如果条件为真, 我们运行一块语句(称为if…块), 否则我们处理另外一块语句(称为else…块), else从句是可选的

num = input("请输入数字:")

if num.isdigit():

print("是数字")

else:

print("不是数字")

24. or:

逻辑判断, or两边有一个为真, 判断结果就是真

1 or 5 # 1 左边为真, 则返回左边的值

0 or {} # {} 左边为假, 则返回右边的值

25. yield:

yield用起来像return, yield在告诉程序, 要求函数返回一个生成器

例如：

def create_generator():

mylist = range(10)

for i in mylist:

yield i*i

g = create_generator()

for i in g:

print(i, end=" ") # 0 1 4 9 16 25 36 49 64 81

26. assret:

断言, 用来在运行中检查程序的正确性, 和其他语言一样的作用

例如:

mylist = []

assert len(mylist) >= 1 # 抛出异常 AssertionError:

print("继续执行")

27. else:

与if配合使用

if 真值表达式:

pass

else:

真值表达式为假执行

28. import:

用import或者from…import来导入相应的模块

例如：

import sys

print("path:" % sys.path)

29. pass:

pass的意思是什么都不要做, 作用是为了弥补语法和空定义上的冲突, 它的好处体现在代码的编写过程之中

比如你可以先写好软件的整个框架, 然后再填好框架内具体函数和class的内容, 如果没有pass编译器会报一堆的错误, 让整个开发很不流畅

例如：

def f(arg):

pass # a function that does nothing (yet)

class C:

pass # a class with no methods(yet)

30. break:

break语句是用来终止循环语句的, 即使哪怕循环条件没有称为false或者序列还没有被完全递归, 也会停止循环语句

注意点: 如果break的是for或while循环，任何对应的循环else块将不执行

for i in range(100):

if i == 50:

print("break跳出当前层循环")

break

else: # for条件不成立的时候执行

print("break后不会执行else")

31. except:

使用try和except语句来铺货异常

try:

num = int(input(">>>"))

num = 100 / num

except Exception as e:

print("Exception万能异常", e)

32. in:

in 成员运算符

for…in是另外一个循环语句, 它在一序列的对象上递归即逐一使用队列中的每个项目

a = 1

if a in [1, 2, 3]:

print("a在列表中") # a在列表中

for i in range(10):

print(i, end=" ") # 0 1 2 3 4 5 6 7 8 9

33 raise

railse主动抛出异常

例如：

class MyException(Exception):

pass

try:

# some code here

raise MyException("railse主动抛出异常")

finally:

print('Arrive finally')

Python的文件操作:

01. 什么是文件:

文件是用于数据存储的单位

文件通常用来长期存储设置

文件中的数据是以字节为单位进行顺序存储的

内存的读写速度快/ 磁盘的读写速度慢

02. 文件的操作步骤:

打开文件 open('xxx'), with open('xxx') as f

读写文件 read() write()

关闭文件 close()

03. 文件的打开函数 open:

open(file, mode='rt') 用于打开一个文件，返回此文件流对象,如果打开失败会触发IOError错误

打开方式:

r

以只读方式打开文件，文件不可写

要打开的文件不存在时会报错

文件的指针将会放在文件的开头

这是默认模式

# file = open('test.txt', 'r')

# FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

file = open('text.txt', 'r')

print(file.read())

# abcdefg

file.write('aaa')

# io.UnsupportedOperation: not writable

file.close()

rb

以二进制格式打开一个文件用于只读，文件不可写

要打开的文件不存在时会报错

文件指针将会放在文件的开头

这是默认模式

# file = open('test.txt', 'rb')

# FileNotFoundError: [Errno 2] No such file or directory: 'test.txt'

file = open('text.txt','rb')

print(file.read())

b'abcdefg'

# file.write(b'aaa')

# io.UnsupportedOperation: not writable

file.close()

r+

打开一个文件用于读写，写入内容为str

文件指针将会放在文件的开头

重新写入的内容从头开始替换

file = open('text.txt', 'r+')

file.write('aaa')

file.close()

file = open('text.txt','r')

print(file.read())

# 'abcdefg'

file.close()

rb+

以二进制格式打开一个文件用于读写，写入内容为bytes

文件指针将会放在文件的开头

重新写入的内容从头开始替换

file = open('text.txt','rb+')

# file.write('aaa')

# TypeError: a bytes-like object is required, not 'str'

file.write(b'aaa')

file.close()

file = open('text.txt','rb')

print(file.read())

# b'aaadefg'

file.close()

w

打开一个文件只用于写入，写入内容为str

文件不可读

如果该文件已存在则将其覆盖，原文件内容将清空

如果该文件不存在，创建新文件

file = open('test.txt', 'w')

创建一个空文件

file = open('text.txt', 'w')

file.write('gfedcba')

file = open('text.txt', 'r')

print(file.read())

file.close()

wb

以二进制格式打开一个文件只用于写入，写入内容为bytes

文件不可读

如果该文件已存在则将其覆盖，原文件内容将清空

如果该文件不存在，创建新文件

file = open('test.txt', 'wb')

创建一个空文件

file = open('text.txt', 'wb')

file.write(b'gfedcba')

file = open('text.txt', 'r')

print(file.read())

file.close()

w+

打开一个文件用于读写，写入内容为str

如果该文件已存在则将其覆盖，原文件内容将清空

如果该文件不存在，创建新文件

file = open('test.txt', 'w+')

创建一个空文件

file = open('text.txt', 'w+')

file.write('gfedcba')

file = open('text.txt', 'r')

print(file.read())

file.close()

wb+

以二进制格式打开一个文件用于读写，写入内容为bytes

如果该文件已存在则将其覆盖

如果该文件不存在，创建新文件

file = open('text.txt', 'wb+')

file.write(b'gfedcba')

file = open('text.txt', 'r')

print(file.read())

file.close()

a

打开一个文件用于追加（只写），写入内容为str

如果该文件已存在，文件指针将会放在文件的结尾，新的内容将会被写入到已有内容之后

如果该文件不存在，创建新文件进行写入

file = open('test.txt', 'a')

创建一个空文件

file = open('text.txt', 'a')

file.write('aaa')

file.close()

file = open('text.txt')

print(file.read())

file.close()

ab

以二进制格式打开一个文件用于追加（只写），写入内容为bytes

如果该文件已存在，文件指针将会放在文件的结尾，新的内容将会被写入到已有内容之后

如果该文件不存在，创建新文件进行写入

file = open('test.txt', 'ab')

创建一个空文件

file = open('text.txt', 'ab')

file.write(b'aaa')

file.close()

file = open('text.txt')

print(file.read())

file.close()

a+

打开一个文件用于追加（读写），写入内容为str

如果该文件已存在，文件指针将会放在文件的结尾，新的内容将会被写入到已有内容之后

如果该文件不存在，创建新文件用于读写

file = open('test.txt', 'a+')

创建一个空文件

file = open('text.txt', 'a+')

file.write('aaa')

file.close()

file = open('text.txt')

print(file.read())

file.close()

ab+

以二进制格式打开一个文件用于追加（读写），写入内容为bytes

如果该文件已存在，文件指针将会放在文件的结尾，新的内容将会被写入到已有内容之后

如果该文件不存在，创建新文件用于读写

file = open('text.txt', 'ab+')

file.write(b'aaa')

file.close()

file = open('text.txt')

print(file.read())

file.close()

04. 文件的关闭方法

F.close() # 关闭文件，释放系统资源

05. 文件操作分为两种类型的操作:

文本文件操作

二进制文件操作

文本文件模式:

mode = 't'

01. 默认文件中存储的内容为字符数据，以行为单位读取，采用系统默认的换行符进行分隔

02. 对于文本文件的读写，需要用字符串(str) 进行读取和写入数据

03. 各操作系统默认的换行符:

Linux 换行符 '\n'

Windows 换行符 '\r\n'

旧的Macintosh 的换行符 '\r'

新的Mac OS 换行符 '\n'

二进制文件操作:

打开模式 : 'b'

默认文件中存储的都是以字节为单位的二进制数据,通常有人为规定的格式，需要以字节为单位进行读写

对二进制文件的读写，需要用字节串(bytes)进行操作

F.read(n) 方法:

F.readline()

F.readlines()

对于二进制文件

F.read()/F.readline() 返回字节串

F.readlines() 返回字节串列表

F.read(n) n代表最大字节数

F.write(x)方法

对于二进制文件，x必须为字节串

F.seek(offset, whence=0)　函数

offset 偏移量:

大于0的数代表向文件末尾方向移动

小于0的数代表向文件头方向移动

whence 相对位置

0 代表从文件头开始偏移

1 代表从当前位置开始偏移

2 代表从文件尾开始偏移

示例:

f = open(".\测试文本\README", "rb") # b 以二进制的方式打开只读文件,且不能指定编码

data = f.read()

# "字符串"---encode--->bytes

# bytes---decode--->"字符串"

print(data)

print(data.decode("utf-8"))

f.close()

f = open(".\测试文本\README", "wb") # b 以二进制的方式打开只写文件,且不能指定编码

f.write(bytes("aaa\r\n", encoding="utf-8"))

f.write("你好".encode("utf-8"))

f.close()

06. 汉字编码:

国标系列:

GB18030 (2字节或4字节编码,共27533个)

GBK (2字节编码,共21003个)

GB2312 (2字节编码,共6763个汉字)

(常用于Windows)

国际标准:

UNICODE16/UNICODE32 <<<--->>> UTF-8

(常用于Linux / Mac OS X / IOS / Android)

UTF-8(8-bit Unicode Transformation Format)

编码字符串:

'gb2312'

'gbk'

'gb18030'

'utf-8'

'ascii'

用于 encode和decode方法中

07. 编码注释:

在源文件的第一行或第二行写入如下格式的内容

# -*- coding:gbk -*-

或

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

是告诉python3解释执行器当前文件的编码是什么

08. 文件操作-读取 read, readable, readline, readlines:

read: 读取所有内容

readable: 判断文件是否可读

readline: 读取一行内容

readlines: 读取所有文件内容保存到列表，包含不显示的字符

# r:以只读方式打开 w：以只写方式打开 a：以只追加方式打开

# 默认以r方式打开

file = open(".\测试文本\README", encoding="gbk") # encoding 指定以什么编码读取文件内容

print(file.readable()) # 判断文件是否可读

print(file.readline()) # 读取一行内容, 每次读取出来的数据都会有一个\n

print(file.readlines()) # 读取所有文件内容保存到列表，包含不显示的字符

file.close() # 关闭文件句柄

09. 文件操作-写入 write, writable, writelines, flush:

write: 写入所有内容

writable: 判断文件是否可写

writelines: 以列表内容写，列表元素必须是字符串

flush: 刷新缓存

# 以w只写方式打开文件，写入内容会覆盖之前的文件内容

file = open(".\测试文本\README", "w", encoding="gbk")

file.write("hello world!") # 写入所有内容

print(file.writable()) # 判断文件是否可写

file.writelines(["111\n","222"]) # 以列表内容写，列表元素必须是字符串

file.flush() # 刷新缓存

file.close()

10. with open 操作文件:

操作完成自动关闭文件

with open(".\测试文本\README", encoding="gbk") as src_f:

msg = src_f.read()

print("with: %s" % msg)

11. 文件操作-复制:

# 1.打开

file_read = open(".\测试文本\README")

file_write = open(".\测试文本\README[复件]", "w")

# 2.读写

while True:

# 读取一行内容

text = file_read.readline()

# 判断是否读到内容

if not text:

break

file_write.write(text)

# 3.关闭

file_read.close()

file_write.close()

12. 文件的其它操作:

f = open("test1", "w", newline="") # newline读取文件中的真正的换行符

print(f.closed) # 判断文件是否关闭

print(f.encoding) # 查看文件的代号

f.flush() # 将写在内存的数据刷到文件中保存

print(f.tell()) # 显示光标所在的位置，光标移动以字节为单位

f.seek(0) # 将光标移动到第0个位置，光标移动以字节为单位

f.truncate(10) # 截取内容，以字节为单位

f.seek(3,0) # 移动光标到3的位置，0：从0位置开始，1：相对位置，2：倒叙,倒叙时第一个参数为负数

f.truncate() # 删掉光标后面的所有内容

f.close()

f1 = open(".\测试文本\test2", "r+", encoding="utf-8") # r+模式,默认情况下光标在开头,必须先读后写,若文件不存在，报错

s = f1.read()

f1.write("444")

f1.flush()

f1.close()

f1 = open(".\测试文本\test3", "w+", encoding="utf-8") # w+操作会清空原来的内容,可读可写，若文件不存在，创建

f1.write("111")

f1.flush()

f1.seek(0)

s1 = f1.read()

print(s1)

f1.close()

13. 文件操作-读日志文件:

f = open(".\测试文本\日志文件", "rb")

for i in f:

offs = -5

while True:

f.seek(offs, 2) # 将文件光标移动到-5位置

data = f.readlines() # 读取所有文件内容保存到列表

if len(data) > 1: # 判断是否有完整的一行

print("文件的最后一行是:%s" % data[-1].decode("utf-8"))

break

offs *= 2

14. 文件操作-人口普查示例:

# 要求：取人口总数

def get_population():

with open(".\测试文本\人口普查", "r", encoding="utf-8") as f:

for i in f:

yield i

p1 = get_population()

g1 = get_population()

# 取单个市人口数

# s1 = eval(g1.__next__())["population"]

# print(s1)

# for循环遍历人口--->不推荐使用，大数据时效率低，内存占用高

# for p in g1:

# p_dic = eval(p)

# print(p_dic["population"])

# 获取总共人口数----->推荐使用表达式，大数据时效率高，内存占用小

all_pop = sum(eval(j)["population"] for j in g1)

print("人口总数:%d" % all_pop)

# 获取指定城市的人口数

def zyl_pop(name):

p1_pop = (eval(j)["population"] for j in p1 if eval(j)["name"] == name)

return p1_pop.__next__()/all_pop

name = "上海"

s2 = zyl_pop(name)

print("%s的人口占全国人口的%.4f%%" % (name, s2*100))

Python的异常处理机制:

01. 异常 exception:

什么是错误:

错误是指由于逻辑或语法等导致一个程序无法正常执行的问题

错误的特点:

有些错误无法预知

什么是异常:

异常是程序出错时标识的一种状态

当异常发生时，程序不会再向下执行，而转去调用此函数的地方待处理此错误并恢复为正常状态

异常的作用:

通知上层调用者有错误产生需要处理

用作信号

为什么要用异常处理机制:

在程序调用层数较深时，向主调函数传递错误信息需要层层的 return 返回比较麻烦，所以用异常处理机制

02. try 语句的两种语法:

try-except 语句

try-finally 语句

01. try-except 语句的语法

try:

可能触发异常的语句

except 错误类型1 [as 变量1]:

异常处理语句1

except 错误类型2 [as 变量2]:

异常处理语句2

except (错误类型3, 错误类型4,...):

异常处理语句3

...

except:

异常处理语句other

else:

末发生异常的语句

finally:

最终语句

作用：

偿试捕获异常,将程序转为正常状态并继续执行

02. try-finally 语句

语法:

try:

可能触发异常的语句

finally:

最终语句

语法说明：

finally 子句不可以省略

一定不存在except 子句

作用：

通常用try-finally 语句来做触发异常时必须要处理的事件，无论异常是否发生，finally 子句都会被执行

注：

try-finally 语句不会改变程序的(正常/异常)状态

03. 完整的异常语法:

try:

# 提示用户输入一个整数

num = int(input("请输入一个整数："))

# 使用8除以用户输入的整数并且输出

print("8除以 %d 结果是：%.2f" % (num, 8 / num))

except ZeroDivisionError:

print("除0错误")

except ValueError:

print("请输入正确的整数")

except Exception as result:

print("未知错误：%s" % result)

else:

print("尝试成功")

finally:

print("无论是否出现错误都会执行的代码")

print("-" * 50)

03. raise 语句:

作用：

触发一个错误，让程序进入异常状态

语法:

raise 异常类型

或

raise 异常对象

示例:

# 出动抛出异常:

def input_password():

# 1.提示用户输入密码

pwd = input("请输入密码：")

# 2.判断密码长度>=8，返回用户输入的密码

if len(pwd) >= 8:

return pwd

# 3.如果<8主动抛出异常

print("主动抛出异常")

# 1> 创建异常对象-可以使用错误信息字符串作为参数

ex = Exception("密码长度不够")

# 2>主动抛出异常

raise ex

# 提示用户输入密码

try:

print(input_password())

except Exception as result:

print(result)

04. 异常的传递特性:

def demo1():

return int(input("请输入整数："))

def demo2():

return demo1()

# 利用异常的传递性，在主程序捕获异常

try:

print(demo2())

except Exception as result:

print("未知错误：%s" % result)

05. 自定义异常:

class CocoException(BaseException):

def __init__(self, msg):

self.msg = msg

try:

raise CocoException("类型错误")

except CocoException as e:

print(e)

06. assert 语句(断言语句)

语法

assert 真值表达式, 错误数据(通常是字符串)

作用:

当真值表达式为False时，用错误数据创建一个AssertionError类型的错误，并进入异常状态

等同于:

if 真值表达式 == False:

raise AssertionError(错误数据)

示例:

# assert断言，终止程序抛出异常

def tset1():

print("大量逻辑处理")

ret = 100

return ret

ret = tset1()

assert ret == 1000

ret1 = ret + 100

print(ret1)

Python的模块发布:

01. 发布模块:

from distutils.core import setup

setup(name="hm_message", # 包名

version="1.0", # 版本

description="itheima's 发送和接收消息模块", # 描述信息

long_description="完整的发送和接收消息模块", # 完整的描述信息

author="Angels〃欧豪", # 作者

author_email="3505584607@qq.com", # 作者邮箱

url="www.ttt.com", # 主页

py_modules=["hm_message.send_message",

"hm_message.receive_message"])

02. 用终端构建模块:

python3 setup.py build

用终端发布压缩包

python setup.py sdist

03. 安装模块

tar -zxvf 模块压缩包

sudo python3 setup.py install

04. 删除模块

用import导入模块，用模块.__file__ 的内置函数找到模块所在路径

删除路径下的模块文件