Python貌似有点火热,上手还是比较简单的,自己找了个教程也偷偷的学习一下,扒了一下网上的图片和数据,感觉并不是很难呀(不过之前换电脑,代码丢了,有点可惜,不过网上教程一抓一大把,随便看看也能扒一些基础的图片了),所以就有了这么一篇基础的学习笔记,自己记录一下,方便自己以后要用的话很快的能够捡起来。
编译型语言
通过编译器,统一编译,一次性执行,最终生成可执行文件(相对执行更快)
代表语言:C语言
解释型语言
逐行解释每一行代码,逐行编译,逐行执行(跨平台运行能力更强),在不同的操作系统上安装不同的解释器,相同源代码使用不同的解释器进行工作
代表语言:Python
优缺点
优点
- 简单,易学
- 可读性强
- 开发速度快
- 面向对象
- 免费,开源
- 可扩展性
- 具有丰富的库
缺点
- 运行速度相对较慢
- 国内市场较小
- 中文资料匮乏
设计哲学
- 优雅(代码工整)
- 明确
- 简单
用一种方法,最好是只有一种方法来做一件事情
Python特点
- 完全面向对象的语言(一切皆对象)
- 拥有一个强大的标准库
- Python社区提供了大量的第三方模块
Python3.0没有考虑向下的兼容
Python解释器
- CPython -- 官方版本的C语言实现
- Jython -- 可以运行在Java平台
- IronPython -- .NET和Mono平台
- PyPy -- Python实现的,支持JIT即时编译
Python变量
1.不用事先声明变量,赋值过程中就包含了变量的声明和定义的过程
2.用"=" 赋值,左边是变量名,右边是变量值
3.使用前必须先被初始化(先被赋值)
4.可以通过del语句删除不再使用的变量
标识符
- 区分大小写
- 第一个字符必须是字母或者下划线
- 不能使用关键字
- 以双划线开头或者结尾的名称通常有特殊意义,不建议使用
模块和包名 -> 全小写,尽量简单
函数名 -> 全小写,多个单词用下划线隔开
类名 -> 首字母大小,采用驼峰命名法
常量名 -> 全大写,多个单词使用下划线隔开
链式赋值
使用同一个对象赋值给多个变量 x = y = 123
系列解包赋值
系列数据赋值给对应相同个数的变量(个数必须保持一致)
a,b,c=4,5,6
常量
Python不支持常量,没有语法规则限制改变一个常量的值。只能约定常量的命名规则,以及在程序的逻辑上不对常量的值做出修改
数字
// 整数除法 7//2 -> 3
** 幂 2**3 -> 8
divmod()函数同事得到商和余数 :
divmod(13,3) ->(4,1) 返回元组
整数
int_var = 1
0b或者0B -> 二进制
0o或者0O -> 八进制
0x或者0X -> 十六进制
自动转型,整数和浮点数相加 自动转化成浮点数
Python3中,int可以存储任意大小的整数,long 被取消
使用int()实现类型转换
1.浮点数直接舍去小数部分。 int(9.9) -> 9
2.布尔值True转为1,False转为0。 int(True) -> 1
3.字符串符合整数格式(浮点数据格式不行)则转换成对应整数,否则报错
时间的表示
1970年1月1日0点开始,以毫秒计算
time.time()获得当前时刻,返回的是以秒为单位精度的浮点值
浮点数
float_var = 1.0
round(value)可以返回四舍五入的值,但不会改变原有值,产生新的值
布尔型
True False
字符串型
字符串
字符串是不可变的 没有字符类型,单个字符也是字符串
Python3直接使用Unicode,可以表示世界上任何书名语言的字符
ord('苏') -> 获取单个字符的Unicode编码。chr(65) 获取Unicode编码表示的字符
Python允许空字符串的存在,不包含任何字符且长度为0
字符串切片slice操作
str = "I Love Python"
print(str[2:5]) // 输出第三个到第五个之间的字符,不包括第六个
print(str[:5]) // 输出0-5之间的字符串 (不包括第六个)
print(str[2:]) // 输出第3-最后一个的字符串(包括最后一个)
print(str * 2) // 输出字符串两次
print(str + " And Java") // 拼接之后输出
print(str[0:5:2]) // 最后一个代表步长step
print(str[-6]) // 倒数6个 Python
print(str[::-1]) // 步长为负,从右到左反向提取
字符串搜索
str.isalnum() // 所有字符全是字母或者数字
str.count("Love") // 指定字符出现的次数
str.find("L") // 返回首次出现的下标
str.rfind("o") // 反向搜索,返回首次出现的下标
去除字符串信息
str.strip("*") // 去除首尾指定信息
str.lstrip("*") // 去除字符串首部左边指定信息
str.rstrip("*") // 去除字符串尾部右边指定信息
大小写转换
str.capitalize() // 产生新的字符串,首字母大写
str.title() // 产生新的字符串,每个单词首字母大写
str.upper() // 产生新的字符串 ,所有字符串转换成大写
str.lower() // 产生新的字符串 ,所有字符串转换成小写
str.swapcase() // 产生新的字符串 ,所有字母大小写转换
排版格式
aa = "str"
print(aa.center(10, "*")) ->***str****
print(aa.ljust(10, "*")) ->str*******
print(aa.rjust(10, "*")) ->*******str
format格式化
aa = "名字是:{0},年龄是:{1}。{0}是个好小伙"
print(aa.format("Steven", 18))
b = "名字是:{name},年龄是:{age}。{name}是个好小伙"
print(b.format(name="Steven", age=18)) // 名字是:Steven,年龄是:18。Steven是个好小伙
填充和对齐
填充和对齐一起使用
^、<、>分别是居中、左对齐、右对齐。后面带宽度
:号后面带填充的字符,只能是一个字符,不指定的话默认是空格填充
a = "我的电话号码是{0:*^11}"
print(a.format(888)) // 我的电话号码是****888****
数字格式化
浮点数通过f,整数通过d进行需要的格式化
数字 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} 3.14 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为 2)
5 {:x<4d} 5xxx 数字补 x (填充右边, 宽度为 4)
10 {:x<4d} 10xx 数字补 x (填充右边, 宽度为 4)
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00E+09 指数记法
13 {:10d} 13 右对齐 (默认, 宽度为 10)
13 {:<10d} 13 左对齐 (宽度为 10)
13 {:^10d} 13 中间对齐 (宽度为 10)
字符串拼接
- +两边都是字符串,则拼接
- +两边都是数字,则加法运算
- +两边类型不同,则抛异常
不换行打印
print("字符串",end = "*") 打印时不会换行,换行符替换成了*符号,使用*连接。*可以是任意字符串
str()实现数字转型字符串
replace()会生成一个新的字符串对象
join字符串拼接
"".join(列表) ->使用将列表中的字符串连接起来
可变字符串 io.StringIo(s)
修改过程中不会产生新的字符串对象
列表
类似于Java中的数组,是一个有序可变的集合容器,支持内置的基础数据结构甚至是列表,列表是可以嵌套的。不同的数据结构可以放在同一个列表中,没有统一类型的限制
list_a = ["str", 1, 1.0]
元组
不可变的列表,在赋值之后就不能二次更改了
tuple_a = ("str", 1, ["a", "b", 1], 2.0)
输出结果: ('str', 1, ['a', 'b', 1], 2.0)
字典(用的比较多)
类似于Java中的map,key-value键值对的形式 无序的容器
dict_a = {
"name": "Steven",
"age": 27,
1: "1800000000"
}
print(dict_a) // {'name': 'Steven', 'age': 27, 1: '1800000000'}
print(dict_a["name"]) // Steven
print(dict_a[1]) // 1800000000
print("name" in dict_a) 判断是否包含改键值// True
print(dict_a.keys()) // dict_keys(['name', 'age', 1])
print(dict_a.values()) // dict_values(['Steven', 27, '1800000000'])
print(dict_a.items()) // dict_items([('name', 'Steven'), ('age', 27), (1, '1800000000')])
逻辑运算符
- and 与关系 类似于Java中的&& x and y ->x 为true,则返回y的值。x为false,则直接返回false
- or 或关系 类似于Java中的|| x or y ->x 为true,则直接返回true。x为false,则返回y的值
- not 非 类似于Java中的!
同一运算符is(is not)
用于比较两个对象的存储单元,实际比较的是对象的地址
整数缓存问题
Python仅仅在命令行中执行时对较小的整数对象进行缓存,范围为[-5,256]之内的整数缓存起来。而在Pycharm或者保存为文件执行时,缓存范围是[-5,任意正整数]
if语句
if (a == b):
print("a == b")
else:
print("a != b")
turtle图形绘制库
\行连接符 续行符
变量位于:堆内存
对象位于:栈内存
序列
序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。
常用的序列结构:字符串、列表、元组、字典、集合
列表:用于存储任意数目、任意类型的数据集合。
列表对象的常用方法汇总如下:
方法 要点 描述
list.append(x) 增加元素 将元素 x 增加到列表 list 尾部
list.extend(aList) 增加元素 将列表 alist 所有元素加到列表 list 尾部
list.insert(index,x) 增加元素 在列表 list 指定位置 index 处插入元素 x
list.remove(x) 删除元素 在列表 list 中删除首次出现的指定元素 x
list.pop([index]) 删除元素 删除并返回列表 list 指定位置 index 处的元素,默认是最后一个元素
list.clear() 删除所有元素 删除列表所有元素,并不是删除列表对象
list.index(x) 访问元素 返回第一个 x 的索引位置,若不存在 x 元素抛出异常
list.count(x) 计数 返回指定元素 x 在列表 list 中出现的次数
len(list) 列表长度 返回列表中包含元素的个数
list.reverse() 翻转列表 所有元素原地翻转
list.sort() 排序 所有元素原地排序
list.copy() 浅拷贝 返回列表对象的浅拷贝
Python的列表大小可变,根据需要随时增加或缩小
列表的创建
基本语法[ ]创建
a = [10,20,'gaoqi','sxt']
a = [] #创建一个空的列表对象
list()创建
使用 list()可以将任何可迭代的数据转化成列表。
a = list() #创建一个空的列表对象
a = list(range(10))
a - > [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a = list("gaoqi,sxt")
a - > ['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']
range()创建整数列表
range()可以帮助我们非常方便的创建整数列表,这在开发中及其有用。语法格式为:
range([start,] end [,step])
start 参数:可选,表示起始数字。默认是 0
end 参数:必选,表示结尾数字。
step 参数:可选,表示步长,默认为 1
python3 中 range()返回的是一个 range 对象,而不是列表。我们需要通过 list()方法将其转换成列表对象
a = [x*2 for x in range(100) if x%9==0] #通过 if 过滤元素
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]
列表元素的增加和删除
当列表增加和删除元素时,列表会自动进行内存管理,大大减少了程序员的负担。但这个特点涉及列表元素的大量移动,效率较低。除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率。
append()方法
原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用。
a = [20,40]
a.append(80)
+运算符操作
并不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次复制到新的列表对象中。这样,会涉及大量的复制操作,对于操作大量元素不建议使用。
a = a+[50]
extend()方法
将目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。
a.extend([50,60])
insert()插入元素
使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后
面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。
类似发生这种移动的函数还有:remove()、pop()、del(),它们在删除非尾部元素时也会发生操作位置后面元素的移动。
a.insert(2,100)
列表元素的删除
本质上是列表的拷贝,将后面的赋值拷贝到前面的值中
del 删除
del a[1]
pop()方法
pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。
a = [10, 20, 30, 40]
a.pop() -> 返回 40
a.pop(1) -> 返回 20
remove()方法
删除首次出现的指定元素,若不存在该元素抛出异常。
a = [10,20,30,40,50,20,30,20,30]
a.remove(20)
列表元素访问和计数
通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则会抛出异常。
index()获得指定元素在列表中首次出现的索引
index()可以获取指定元素首次出现的索引位置。语法是:index(value,[start,[end]])。其中,
start 和 end 指定了搜索的范围。
count()获得指定元素在列表中出现的次数
len()返回列表长度
成员资格判断
判断列表中是否存在指定的元素,我们可以使用 count()方法,返回 0 则表示不存在,返回大于 0 则表示存在。但是,一般我们会使用更加简洁的 in 关键字来判断,直接返回 True或 False。
切片操作
切片是 Python 序列及其重要的操作,适用于列表、元组、字符串等等
切片 slice 操作可以让我们快速提取子列表或修改。标准格式为:
[起始偏移量 start:终止偏移量 end[:步长 step]]
操作和说明 示例 结果
[:] 提取整个列表 [10,20,30][:] [10,20,30]
[start:]从 start 索引开始到结尾 [10,20,30][1:] [20,30]
[:end]从头开始直到 end-1 [10,20,30][:2] [10,20]
[start:end]从start到 end-1 [10,20,30,40][1:3] [20,30]
[start:end:step] 从 start 提取到 end-1,步长是 step [10,20,30,40,50,60,70][1:6:2] [20, 40, 60]
其他操作(三个量为负数)的情况:
示例 说明 结果
[10,20,30,40,50,60,70][-3:] 倒数三个 [50,60,70]
10,20,30,40,50,60,70][-5:-3] 倒数第五个到倒数第三个(包头不包尾) [30,40]
[10,20,30,40,50,60,70][::-1] 步长为负,从右到左反向提取 [70, 60, 50, 40, 30, 20, 10]
切片操作时,起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围,也不会报错。起始
偏移量小于 0 则会当做 0,终止偏移量大于“长度-1”会被当成”长度-1”
列表的遍历
for obj in listObj:
print(obj)
列表排序
修改原列表,不建新列表的排序
a.sort() #默认是升序排列
a.sort(reverse=True) #降序排列
random.shuffle(a) #打乱顺序
建新列表的排序
通过内置函数 sorted()进行排序,这个方法返回新列表,不对原列表做修改。
a = sorted(a) #默认升序
c = sorted(a,reverse=True) #降序
reversed()返回迭代器
内置函数 reversed()也支持进行逆序排列,与列表对象 reverse()方法不同的是,内置函数
reversed()不对原列表做任何修改,只是返回一个逆序排列的迭代器对象。
迭代器只能使用一次 第二次会返回空
a = [20,10,30,40]
c = reversed(a)
max 和 min
用于返回列表中最大和最小值。
max(a)
min(a)
sum
对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。
sum(a)
多维列表
二维列表
一维列表可以帮助我们存储一维、线性的数据。
二维列表可以帮助我们存储二维、表格的数据。
a = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小一",20,10000,"深圳"],
]
print(a[1][0],a[1][1],a[1][2])
元组 tuple
列表属于可变序列,可以任意修改列表中的元素。元组属于不可变序列,不能修改元组中的元素。因此,元组没有增加元素、修改元素、删除元素相关的方法。
元组支持如下操作:
1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数:元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。
-
通过()创建元组。小括号可以省略。
a = (10,20,30) 或者 a = 10,20,30
如果元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1)解释为整数 1,(1,)解释为元组。
-
通过 tuple()创建元组
tuple(可迭代的对象)b = tuple() #创建一个空元组对象 b = tuple("abc") b = tuple(range(3)) b = tuple([2,3,4])
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
元组的元素访问和计数
-
元组的元素不能修改
-
元组的元素访问和列表一样,只不过返回的仍然是元组对象。
a = (20,10,30,9,8) a[1] -> 10 a[1:3] -> (10, 30) a[:4] -> (20, 10, 30, 9)
-
列表关于排序的方法 list.sort()是修改原列表对象,元组没有该方法。如果要对元组排序,只能使用内置函数 sorted(tupleObj),并生成新的列表对象。
a = (20,10,30,9,8) sorted(a) -> [8, 9, 10, 20, 30]
zip
zip(列表 1,列表 2,...)将多个列表对应位置的元素组合成为元组,并返回这个 zip 对象
a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
list(d) -> [(10, 40, 70), (20, 50, 80), (30, 60, 90)]
生成器推导式创建元组
从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号。列表推
导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象。
我们可以通过生成器对象,转化成列表或者元组。也可以使用生成器对象的__next__()
方法进行遍历,或者直接作为迭代器对象来使用。不管什么方式使用,元素访问结束后,如果需要重新访问其中的元素,必须重新创建该生成器对象。
s = (x * 2 for x in range(5))
print(tuple(s)) -> (0, 2, 4, 6, 8) #只能访问一次元素。第二次就为空了。需要再生成一次
元组总结
- 元组的核心特点是:不可变序列。
- 元组的访问和处理速度比列表快。
- 与整数和字符串一样,元组可以作为字典的键,列表则永远不能作为字典的键使用。
字典
字典是“键值对”的无序可变序列,字典中的每个元素都是一个“键值对”,包含:“键
对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
键”是任意的不可变数据,比如:整数、浮点数、字符串、元组。但是:列表、
字典、集合这些可变对象,不能作为“键”。并且“键”不可重复。
字典的创建
-
我们可以通过{}、dict()来创建字典对象。
a = {'name':'Steven','age':18,'job':'programmer'} b = dict(name='Steven',age=18,job='programmer') a = dict([("name","Steven"),("age",18)]) a = dict({("name", "Steven"), ("age", 18)}) a = dict({'name': 'Steven', 'age': 18, 'job': 'programmer'}) c = {} #空的字典对象 d = dict() #空的字典对象
-
通过 zip()创建字典对象
k = ['name','age','job'] v = ['Steven',18,'programmer'] d = dict(zip(k,v)) print(d) -> {'name': 'Steven', 'age': 18, 'job':'programmer'}
-
通过 fromkeys 创建值为空的字典
a = dict.fromkeys(['name','age','job']) print(a) -> {'name': None, 'age': None, 'job': None} # none 是一个值,表示没有赋值
字典元素的访问
a = {'name':'Steven','age':18,'job':'programmer'}
-
通过 [键] 获得“值”。若键不存在,则抛出异常。
a['name'] -> 'Steven'
-
通过 get()方法获得“值”。推荐使用。优点是:指定键不存在,返回 None;也可以设定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”。
a.get('name') -> 'Steven' a.get('sex','一个男人') -> '一个男人'
-
列出所有的键值对
a.items() -> dict_items([('name', 'Steven'), ('age', 18), ('job', 'programmer')])
-
列出所有的键,列出所有的值
a.keys() -> dict_keys(['name', 'age', 'job']) a.values() -> dict_values(['Steven', 18, 'programmer'])
-
len() 键值对的个数
len(a) a.__len__()
-
检测一个“键”是否在字典中
print("name" in a) -> True
字典元素添加、修改、删除
-
给字典新增“键值对”。如果“键”已经存在,则覆盖旧的键值对;如果“键”不存在,
则新增“键值对”。a['address']='世界大厦1101' a['age']=16 print(a) -> {'name': 'Steven', 'age': 16, 'job': 'programmer', 'address': '世界大厦1101'}
-
使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复,则直接覆盖
b = {'name': 'StevenSon', 'money': 1000, 'sex': '男的'} a.update(b) print(a) -> {'name': 'StevenSon', 'age': 16, 'job': 'programmer', 'money': 1000, 'sex': '男的'}
-
字典中元素的删除,可以使用 del()方法;或者 clear()删除所有键值对;pop()删除指定键值对,并返回对应的“值对象”;
del(a["name"]) print(a) -> {'age': 18, 'job': 'programmer'} a_value = a.pop("age") print(a) -> {'job': 'programmer'} print(a_value) -> 18
-
popitem() :随机删除和返回该键值对。若想一个接一个地移除并处理项,这个方法就非常有效(因为不用首先获取键的列表)。
print(a.popitem()) -> ('job', 'programmer') print(a) -> {'name': 'Steven', 'age': 18}
序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
x,y,z=(20,30,10)
(a,b,c)=(9,8,10)
[a,b,c]=[10,20,30]
序列解包用于字典时,默认是对“键”进行操作; 如果需要对键值对操作,则需要使用
items();如果需要对“值”进行操作,则需要使用 values();
s = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s #默认对键进行操作
name,age,job=s.items() #对键值对进行操作
name,age,job=s.values() #对值进行操作
字典核心底层原理(重要)
字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组),数组的
每个单元叫做 bucket。每个 bucket 有两部分:一个是键对象的引用,一个是值对象的引用。
由于,所有 bucket 结构和大小一致,我们可以通过偏移量来读取指定 bucket。
字典底层原理.png 字典底层原理2.png根据键查找“键值对”的底层过程
字典底层取值.png用法总结:
-
键必须可散列
(1) 数字、字符串、元组,都是可散列的。
(2) 自定义对象需要支持下面三点:1 支持 hash()函数 2 支持通过__eq__()方法检测相等性。 3 若 a==b 为真,则 hash(a)==hash(b)也为真。
-
字典在内存中开销巨大,典型的空间换时间。
-
键查询速度很快
-
往字典里面添加新建可能导致扩容,导致散列表中键的次序变化。因此,不要在遍历字典的同时进行字典的修改。 会报RuntimeError: dictionary changed size during iteration错误
集合
集合是无序可变,元素不能重复。实际上,集合底层是字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的。
集合创建和删除
-
使用{}创建集合对象,并使用 add()方法添加元素
a = {3, 5, 7} a.add(9)
-
使用 set(),将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据,则只保留一个。
b = set(a)
-
remove()删除指定元素;clear()清空整个集合
a.remove(3)
集合相关操作
Python 对集合提供了并集、交集、差集等运算
a = {1, 3, 'sxt'}
b = {'he', 'it', 'sxt'}
a|b 或者 a.union(b) #并集 -> {1, 3, 'sxt', 'he', 'it'}
a&b 或者 a.intersection(b) #交集 ->{'sxt'}
a-b 或者 a.difference(b) #差集 ->{1, 3}
控制语句
选择结构
单分支选择结构
if 语句单分支结构的语法形式如下:
if 条件表达式:
语句/语句块
num = input("输入一个数字:")
if int(num)<10:
print(num)
条件表达式详解
在选择和循环结构中,条件表达式的值为 False 的情况如下:
False、0、0.0、空值 None、空序列对象(空列表、空元祖、空集合、空字典、空字符串)、空 range 对象、空迭代对象。其他情况均为True
条件表达式中,不能有赋值操作符“=”
双分支选择结构
双分支结构的语法格式如下:
if 条件表达式 :
语句 1/语句块 1
else:
语句 2/语句块 2
三元条件运算符
Python 提供了三元运算符,用来在某些简单双分支赋值情况。三元条件运算符语法格式如下:
条件为真时的值 if (条件表达式) else 条件为假时的值
多分支选择结构
多分支选择结构的语法格式如下:
if 条件表达式 1 :
语句 1/语句块 1
elif 条件表达式 2:
语句 2/语句块 2
.
.
.
elif 条件表达式 n :
语句 n/语句块 n
[else:
语句 n+1/语句块 n+1
]
【注】计算机行业,描述语法格式时,使用中括号[ ]通常表示可选,非必选。
选择结构嵌套
选择结构可以嵌套,使用时一定要注意控制好不同级别代码块的缩进量,因为缩进量决定了代码的从属关系。
循环结构
循环结构用来重复执行一条或多条语句。表达这样的逻辑:如果符合条件,则反复执行循环体里的语句。在每次执行完后都会判断一次条件是否为 True,如果为 True 则重复执行循环体里的语句。
循环体里面的语句至少应该包含改变条件表达式的语句,以使循环趋于结束;否则,就会变成一个死循环。
while 循环
while 循环的语法格式如下:
while 条件表达式:
循环体语句
for 循环和可迭代对象遍历
for 循环通常用于可迭代对象的遍历。for 循环的语法格式如下:
for 变量 in 可迭代对象:
循环体语句
可迭代对象
Python 包含以下几种可迭代对象:
- 序列。包含:字符串、列表、元组
- 字典
- 迭代器对象(iterator)
- 生成器函数(generator)
- 文件对象
range 对象
range 对象是一个迭代器对象,用来产生指定范围的数字序列。格式为:
range(start, end [,step])
生成的数值序列从 start 开始到 end 结束(不包含 end)。若没有填写 start,则默认从 0开始。step 是可选的步长,默认为 1。
for i in range(10) 产生序列:0 1 2 3 4 5 6 7 8 9
for i in range(3,10) 产生序列:3 4 5 6 7 8 9
for i in range(3,10,2) 产生序列:3 5 7 9
break 语句
break 语句可用于 while 和 for 循环,用来结束整个循环。当有嵌套循环时,break 语句只能跳出最近一层的循环。
continue 语句
continue 语句用于结束本次循环,继续下一次。多个循环嵌套时,continue 也是应用于最
近的一层循环。
else 语句
while、for 循环可以附带一个 else 语句(可选)。如果 for、while 语句没有被 break 语句
结束,则会执行 else 子句,否则不执行。语法格式如下:
while 条件表达式:
循环体
else:
语句块
或者:
for 变量 in 可迭代对象:
循环体
else:
语句块
循环代码优化
编写循环时,遵守下面三个原则可以大大提高运行效率,避免不必要的低效计算:
- 尽量减少循环内部不必要的计算
- 嵌套循环中,尽量减少内层循环的计算,尽可能向外提。
- 局部变量查询较快,尽量使用局部变量
其他优化手段
- 连接多个字符串,使用 join()而不使用+
- 列表进行元素插入和删除,尽量在列表尾部操作
使用 zip()并行迭代
我们可以通过 zip()函数对多个序列进行并行迭代,zip()函数在最短序列“用完”时就会停止。
names = ("Steven","高老二","高老三","高老四")
ages = (18,16,20,25)
jobs = ("老师","程序员","公务员")
for name,age,job in zip(names,ages,jobs):
print("{0}--{1}--{2}".format(name,age,job)
执行结果:
Steven--18--老师
高老二--16--程序员
高老三--20--公务员
推导式创建序列
推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合,
从而避免冗长的代码。推导式是典型的 Python 风格,会使用它代表你已经超过 Python 初
学者的水平。
列表推导式
列表推导式生成列表对象,语法如下:
[表达式 for item in 可迭代对象 ]
或者:
{表达式 for item in 可迭代对象 if 条件判断
[x*2 for x in range(1,5)] -> [2, 4, 6, 8]
[x*2 for x in range(1,20) if x5==0 ] -> [10, 20, 30]
[a for a in "abcdefg"] -> ['a', 'b', 'c', 'd', 'e', 'f', 'g']
cells = [(row,col) for row in range(1,10) for col in range(1,10)] #可以使用两个循环
字典推导式
字典的推导式生成字典对象,格式如下:
{key_expression : value_expression for 表达式 in 可迭代对象}
my_text = ' i love you, i love sxt,i love Steven'
char_count = {c:my_text.count(c) for c in my_text}
集合推导式
集合推导式生成集合,和列表推导式的语法格式类似:
{表达式 for item in 可迭代对象 }
或者:
{表达式 for item in 可迭代对象 if 条件判断}
生成器推导式(生成元组)
元组是没有推导式的,推导式推导出的是一个生成器,可以通过生成器生成元组。一个生成器只能运行一次。第一次迭代可以得到数据,第二次迭代发现数据已经没有了。
tunple((x for x in range(4))) -> (0, 1, 2, 3)
函数用法和底层分析
Python 函数的分类
Python 中函数分为如下几类:
- 内置函数
我们前面使用的 str()、list()、len()等这些都是内置函数,我们可以拿来直接使用。 - 标准库函数
我们可以通过 import 语句导入库,然后使用其中定义的函数 - 第三方库函数
Python 社区也提供了很多高质量的库。下载安装这些库后,也是通过 import 语句导
入,然后可以使用这些第三方库的函数 - 用户自定义函数
函数的定义和调用
核心要点
Python 中,定义函数的语法如下:
def 函数名 ([参数列表]) :
'''文档字符串'''
函数体/若干语句
-
Python 执行 def 时,会创建一个函数对象,并绑定到函数名变量上。即函数也是一个对象
-
参数列表
(1) 圆括号内是形式参数列表,有多个参数则使用逗号隔开
(2) 形式参数不需要声明类型,也不需要指定函数返回值类型
(3) 无参数,也必须保留空的圆括号
(4) 实参列表必须与形参列表一一对应
-
return 返回值
(1) 如果函数体中包含 return 语句,则结束函数执行并返回值;
(2) 如果函数体中不包含 return 语句,则返回 None 值。
return 返回值要点:
- 如果函数体中包含 return 语句,则结束函数执行并返回值;
- 如果函数体中不包含 return 语句,则返回 None 值。
- 要返回多个返回值,使用列表、元组、字典、集合将多个值“存起来”即可。
文档字符串(函数的注释)
通过三个单引号或者三个双引号来实现,中间可以加入多行文字进行说明。
调用 help(函数名.__doc__)可以打印输出函数的文档字符串
变量的作用域( 全局变量和局部变量)
全局变量:
-
在函数和类定义之外声明的变量。作用域为定义的模块,从定义位置开始直到模块
结束。 -
全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。
-
全局变量一般做常量使用。
-
函数内要改变全局变量的值,使用 global 声明一下
global a #如果要在函数内改变全局变量的值,增加 global 关键字声明
局部变量:
- 在函数体中(包含形式参数)声明的变量。
- 局部变量的引用比全局变量快,优先考虑使用。
- 如果局部变量和全局变量同名,则在函数内隐藏全局变量,只使用同名的局部变量
参数的传递
函数的参数传递本质上就是:从实参到形参的赋值操作。 Python 中“一切皆对象”,
所有的赋值操作都是“引用的赋值”。所以,Python 中参数的传递都是“引用传递”,不
是“值传递”。具体操作时分为两类:
- 对“可变对象”进行“写操作”,直接作用于原对象本身。
- 对“不可变对象”进行“写操作”,会产生一个新的“对象空间”,并用新的值填
充这块空间。(起到其他语言的“值传递”效果,但不是“值传递”)
可变对象:
字典、列表、集合、自定义的对象等
不可变对象:
数字、字符串、元组、function 等
传递可变对象的引用
传递参数是可变对象(例如:列表、字典、自定义的其他可变对象等),实际传递的还是对
象的引用。在函数体中不创建新的对象拷贝,而是可以直接修改所传递的对象
传递可变对象的引用
传递参数是可变对象,实际传递的还是对象的引用。在函数体中不创建新的对象拷贝,而是可以直接修改所传递的对象。
a = 100
def f1(n):
print("n:",id(n)) #传递进来的是 a 对象的地址
n = n+200 #由于 a 是不可变对象,因此创建新的对象 n
print("n:",id(n)) #n 已经变成了新的对象
print(n)
f1(a)
print("a:",id(a)
执行结果:
n: 1663816464
n: 46608592
300
a: 1663816464
浅拷贝和深拷贝
内置函数:copy(浅拷贝)、deepcopy(深拷贝)。
浅拷贝:不拷贝子对象的内容,只是拷贝子对象的引用。
深拷贝:会连子对象的内存也全部拷贝一份,对子对象的修改不会影响源对象
传递不可变对象包含的子对象是可变的情况
传递不可变对象时。不可变对象里面包含的子对象是可变的。则方法内修改了这个可变对象,源对象也发生了变化
参数的几种类型
位置参数
函数调用时,实参默认按位置顺序传递,需要个数和形参匹配。按位置传递的参数,称为:“位置参数”。
默认值参数
我们可以为某些参数设置默认值,这样这些参数在传递时就是可选的。称为“默认值参数”。默认值参数放到位置参数后面。
命名参数
我们也可以按照形参的名称传递参数,称为“命名参数”,也称“关键字参数”。参数传递顺序可变
可变参数
可变参数指的是“可变数量的参数”。分两种情况:
-
*param(一个星号),将多个参数收集到一个“元组”对象中。
-
**param(两个星号),将多个参数收集到一个“字典”对象中。
def f1(a,b,*c): print(a,b,c) f1(8,9,19,20) def f2(a,b,**c): print(a,b,c) f2(8,9,name='gaoqi',age=18) def f3(a,b,*c,**d): print(a,b,c,d) f3(8,9,20,30,name='gaoqi',age=18
强制命名参数
在带星号的“可变参数”后面增加新的参数,必须在调用的时候“强制命名参数”
lambda 表达式和匿名函数
lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数
的方法。lambda 函数实际生成了一个函数对象。
lambda 表达式只允许包含一个表达式,不能包含复杂语句,该表达式的计算结果就是函数
的返回值
lambda 表达式的基本语法如下:
lambda arg1,arg2,arg3... : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是:表达式的运算结果。
eval()函数
功能:将字符串 str 当成有效的表达式来求值并返回计算结果。
nonlocal 关键字
nonlocal 用来声明外层的局部变量。
global 用来声明全局变量
LEGB 规则
Python 在查找“名称”时,是按照 LEGB 规则查找的:
Local-->Enclosed-->Global-->Built in
Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数(一个函数包裹另一个函数,闭包)
Global 指的是模块中的全局变量
Built in 指的是 Python 为自己保留的特殊名称。
对象
类
类的定义
定义类的语法格式:
class 类名:
类体
- 类名必须符合“标识符”的规则;一般规定,首字母大写,多个单词使用“驼峰原则”。
- 类体中我们可以定义属性和方法。
- 属性用来描述数据,方法(即函数)用来描述这些数据相关的操作。
__init__构造方法和__new__方法
类是抽象的,也称之为“对象的模板”。
__init__()的要点如下:
- 名称固定,必须为:__init__()
- 第一个参数固定,必须为:self。 self 指的就是刚刚创建好的实例对象。
- 构造函数通常用来初始化实例对象的实例属性
- 通过“类名(参数列表)”来调用构造函数
- __init__()方法:初始化创建好的对象,初始化指的是:“给实例属性赋值”
- __new__()方法: 用于创建对象,但我们一般无需重定义该方法。
- 如果我们不定义__init__()方法,系统会提供一个默认的__init__()方法。如果我们定义了带参
的__init__()方法,系统不创建默认的__init__()方法。
注:
Python 中的 self 相当于 C++中的 self 指针,JAVA 和 C#中的 this 关键字。
Python 中,self 必须为构造函数的第一个参数,名字可以任意修改。但一般遵守惯例,都叫做 self。
实例属性和实例方法
实例属性
实例属性是从属于实例对象的属性,也称为“实例变量”。
使用要点:
-
实例属性一般在\__init__()方法中通过如下代码定义:
self.实例属性名 = 初始值 -
在本类的其他实例方法中,也是通过 self 进行访问:
self.实例属性名 -
创建实例对象后,通过实例对象访问:
obj01 = 类名() #创建对象,调用__init__()初始化属性 obj01.实例属性名 = 值 #可以给已有属性赋值,也可以新加属性
实例方法
实例方法是从属于实例对象的方法。实例方法的定义格式如下:
def 方法名(self [, 形参列表]):
函数体
方法的调用格式如下:
对象.方法名([实参列表])
要点:
- 定义实例方法时,第一个参数必须为 self。和前面一样,self 指当前的实例对象。
- 调用实例方法时,不需要也不能给 self 传参。self 由解释器自动传参。
函数和方法的区别
- 都是用来完成一个功能的语句块,本质一样。
- 方法调用时,通过对象来调用。方法从属于特定实例对象,普通函数没有这个特点。
- 直观上看,方法定义时需要传递 self,函数不需要。
其他操作:
- dir(obj)可以获得对象的所有属性、方法
- obj._dict_ 对象的属性字典
- pass 空语句
- isinstance(对象,类型) 判断“对象”是不是“指定类型”
类对象、类属性、类方法、静态方法
类对象
类对象的类型就是type
pass 为空语句。就是表示什么都不做,只是作为一个占位符存在。当你写代码时,
遇到暂时不知道往方法或者类中加入什么时,可以先用 pass 占位,后期再补上。
类属性
类属性是从属于“类对象”的属性,也称为“类变量”。由于,类属性从属于类对象,可以
被所有实例对象共享。
类属性的定义方式:
class 类名:
类变量名= 初始值
class Student:
company = "SXT" #类属性
count = 0 #类属性
def __init_(self,name,score):
self.name = name #实例属性
self.score = scor
类方法
类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义,格式如下:
@classmethod
def 类方法名(cls [,形参列表]) :
函数体
要点如下:
- @classmethod 必须位于方法上面一行
- 第一个 cls 必须有;cls 指的就是“类对象”本身;
- 调用类方法格式:“类名.类方法名(参数列表)”。 参数列表中,不需要也不能给 cls 传
值。 - 类方法中访问实例属性和实例方法会导致错误
- 子类继承父类方法时,传入 cls 是子类对象,而非父类对象
静态方法
Python 中允许定义与“类对象”无关的方法,称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别,只不过“静态方法”放到了“类的名字空
间里面”,需要通过“类调用”。
静态方法通过装饰器@staticmethod 来定义,格式如下:
@staticmethod
def 静态方法名([形参列表]) :
函数体
要点如下:
- @staticmethod 必须位于方法上面一行
- 调用静态方法格式:“类名.静态方法名(参数列表)”。
- 静态方法中访问实例属性和实例方法会导致错误
__del__方法(析构函数)和垃圾回收机制
__del__方法称为“析构方法”,用于实现对象被销毁时所需的操作。
__del__方法称为“析构方法”,用于实现对象被销毁时所需的操作。
可以通过 del 语句删除对象,从而保证调用__del__方法。系统会自动提供__del__方法,一般不需要自定义析构方法。
__call__方法和可调用对象
定义了__call__方法的对象,称为“可调用对象”,即该对象可以像函数一样被调用。
class SalaryAccount:
def __call__(self, salary):
yearSalary = salary*12
daySalary = salary//30
hourSalary = daySalary//8
return dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)
s = SalaryAccount()
print(s(5000)
{'monthSalary': 5000, 'yearSalary': 60000, 'daySalary': 166, 'hourSalary': 20}
方法没有重载
Python 中,方法的的参数没有声明类型(调用时确定参数的类型),参数的数量也可以由
可变参数控制。
不要使用重名的方法!Python 中方法没有重载
方法的动态性
Python 是动态语言,我们可以动态的为类添加新的方法,或者动态的修改类的已有的方法。
Python 一切皆对象
私有属性和私有方法(实现封装)
Python 对于类的成员没有严格的访问控制限制,这与其他面向对象语言有区别。关于私有
属性和私有方法,有如下要点:
- 通常我们约定,两个下划线开头的属性是私有的(private)。其他为公共的(public)。
- 类内部可以访问私有属性(方法)
- 类外部不能直接访问私有属性(方法)
- 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)p._Employee__age
@property 装饰器
@property 可以将一个方法的调用方式变成“属性调用”。
class Employee
def __init__(self,name,salary):
self.name = name
self.__salary = salary
@property #相当于 salary 属性的 getter 方法
def salary(self):
print("月薪为{0},年薪为{1}".format(self.__salary,(12*self.__salary)))
return self.__salary;
@salary.setter
def salary(self,salary): #相当于 salary 属性的 setter 方法
if(0<salary<1000000):
self.__salary = salary
else:
print("薪水录入错误!只能在 0-1000000 之间"
面向对象
继承
语法格式
Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
class 子类类名(父类 1[,父类 2,...]):
类体
默认父类是 object 类
class Person:
def __init__(self,name,age):
self.name = name
self.__age = age
class Student(Person):
def __init__(self,name,age,score):
self.score = score
Person.__init__(self,name,age) #构造函数中包含调用父类构造函数。根据需要,不是必须。
子类并不会自动调用父类的\_\_init\_\_(),我们必须显式的调用
类成员的继承和重写
- 成员继承:子类继承了父类除构造方法之外的所有成员。
- 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”
重写__str__()方法
object 有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置函数 str()
经常用于 print()方法,帮助我们查看对象的信息。__str__()可以重写。
多重继承
Python 支持多重继承,一个子类可以有多个“直接父类”。这样,就具备了“多个父类”的特点。但是由于这样会被“类的整体层次”搞的异常复杂,尽量避免使用。
MRO()
Python 支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将
“从左向右”按顺序搜索。
MRO(Method Resolution Order):方法解析顺序。 我们可以通过 mro()方法获得
“类的层次结构”,方法解析顺序也是按照这个“类的层次结构”寻找的。
super()获得父类定义
在子类中,如果想要获得父类的方法时,我们可以通过 super()来做。
super()代表父类的定义,不是父类对象。
多态
多态(polymorphism)是指同一个方法调用由于对象不同可能会产生不同的行为。
- 多态是方法的多态,属性没有多态。
- 多态的存在有 2 个必要条件:继承、方法重写。
特殊方法和运算符重载
Python 的运算符实际上是通过调用对象的特殊方法实现的。
常见的特殊方法统计如下:
方法 说明 例子
__init__ 构造方法 对象创建:p = Person()
__del__ 析构方法 对象回收
__repr__,__str__ 打印,转换 print(a)
__call__ 函数调用 a()
__getattr__ 点号运算 a.xxx
__setattr__ 属性赋值 a.xxx = value
__getitem__ 索引运算 a[key]
__setitem__ 索引赋值 a[key]=value
__len__ 长度 len(a)
运算符 特殊方法 说明
运算符+ __add__ 加法
运算符- __sub__ 减法
<,<=,== __lt__,__le__,__eq__ 比较运算符
>,>=,!= __gt__,__ge__,__ne__ 比较运算符
|,^,& __or__,__xor__,__and__ 或、异或、与
<<,>> __lshift__,__rshift__ 左移、右移
*,/,%,// __mul__,__truediv__,__mod__,__floordiv__ 乘、浮除、模运算
(取余)、整数除
** __pow__ 指数运算
每个运算符实际上都对应了相应的方法
特殊属性
Python 对象中包含了很多双下划线开始和结束的属性,这些是特殊属性,有特殊用法
特殊方法 含义
obj.__dict__ 对象的属性字典
obj.__class__ 对象所属的类
class.__bases__ 类的基类元组(多继承)
class.__base__ 类的基类
class.__mro__ 类层次结构
class.__subclasses__() 子类列表
对象的浅拷贝和深拷贝
- 变量的赋值操作
只是形成两个变量,实际还是指向同一个对象。
- 浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时,对象包含的子对象内容不拷贝。因此,源对象
和拷贝对象会引用同一个子对象。
- 深拷贝
使用 copy 模块的 deepcopy 函数,递归拷贝对象中包含的子对象。源对象和拷贝对象
所有的子对象也不同
组合
is-a”关系,我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。
“has-a”关系,我们可以使用“组合”,也能实现一个类拥有另一个类的方法和属性。
设计模式_工厂模式实现
工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。
class CarFactory:
def createCar(self,brand):
if brand == "奔驰":
return Benz()
elif brand == "宝马":
return BMW()
elif brand == '比亚迪':
return BYD()
else:
return "未知品牌,无法创建"
class Benz:
pass
class BMW:
pass
class BYD:
pass
factory = CarFactory()
c1 = factory.createCar("奔驰")
c2 = factory.createCar("宝马")
设计模式_单例模式实现
单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。
class MySingleton:
__obj = None
__init_flag = True
def __new__(cls, *args, **kwargs):
if cls.__obj == None:
cls.__obj = object.__new__(cls) # 创建父类对象
return cls.__obj
def __init__(self,name):
if MySingleton.__init_flag: # 保证初始化只执行一次
print( "init....")
self.name = name
MySingleton.__init_flag = False
a = MySingleton( "aa")
print(a)
b = MySingleton( "bb")
print(b)
异常
在执行程序的时候遇到错误,会停止程序的执行,并提示错误信息,这就是异常
捕获异常
语法格式:
try:
# 尝试执行的代码
except:
# 出现错误的处理
捕获特殊错误类型
程序运行出错的第一个单词,就是错误类型
try:
# 尝试执行的代码
pass
except 错误类型1:
# 出现错误类型1的处理
pass
except (错误类型2, 错误类型3):
# 出现错误类型2或者错误类型3的处理
pass
捕获未知错误
except Exception as result: # result变量接收错误信息
print("未知错误 %s" % result)
异常捕获完整语法
try:
pass
except ValueError:
pass
except Exception as result:
pass
else:
# 没有异常执行的代码
pass
finally:
# 无论是否出现异常,都会执行。最后执行
pass
异常的传递
当函数/方法出现错误时,会把异常传递给函数/方法的调用处,直到主程序
当异常抛出到主程序时,仍然没有进行异常捕获,程序就会终止
利用异常的传递性,可以在主程序中捕获异常
抛出raise异常
-
创建一个Exception的对象
-
使用raise关键字抛出异常对象
# 创建异常对象 ex = Exception("异常描述信息") # 主动抛出异常 raise ex # raise + 异常对象
模块
模块的导入
import导入
模块导入关键字import,导入模块应该单行导入一个模块
模块名.的方式使用模块中提供的类,全局变量,函数
使用关键字as指定模块的别名,别名命名方法使用大驼峰命名法(单个单词首字母大写)
import 模块名 as 模块名
from...import导入
从一个模块中,导入部分工具
from 模块名 import 工具名
通过from导入之后,不需要通过模块名.的方式来使用。可以直接使用工具名进行使用
注意:如果两个模块,存在同名的函数,那么后导入的函数,会覆盖掉之前导入的函数。
一旦发现有同名的函数,可以使用as指定别名
模块的搜索顺序
- 搜索当前目录指定模块名的文件,如果有就直接导入
- 如果没有,再搜索系统目录
__name__属性
文件被导入时,能够直接执行的代码不需要被执行!因此需要使用__name__属性来做判断。
__name__是Python的一个内置属性,记录着一个字符串.
如果是被其他文件导入的,__name__就是模块名
如果是当前执行的程序__name__就是__main__
Python文件的标准代码格式:
# 导入模块
# 定义全局变量
# 定义类
# 定义函数
def main():
pass
# 根据__name__属性判断是否需要执行代码
if __name__="__main__"
main()
包
- 包是一个包含多个模块的特殊目录
- 目录下有一个特殊文件:__init__.py
- 包的命名方式和变量名一样,小写字母+下划线
使用import 包名 可以一次性导入包中的所有模块
__init__.py
要在外界使用包中的模块,需要在__init__.py文件中指定对外界提供的模块列表
from . import 模块列表
发布模块
将自己开发的模块,分享给其他人
制作发布压缩包
制作压缩包步骤.png安装删除模块
安装删除模块.pngpip安装删除模块
pip安装删除模块.png文件
文件操作步骤
- 打开文件 open()
- 读写文件 read() write()
- 关闭文件 close()
read()函数运行之后会将指针移动到文件末尾,再次读的话是读取不到内容的
文件复制
小文件
小文件直接复制
file = open("move.json", encoding="utf-8")
text = file.read()
copyFile = open("copyMove.json", mode="w", encoding="utf-8")
copyFile.write(text)
file.close()
copyFile.close()
大文件
大文件需要逐行复制
file = open("move.json", encoding="utf-8")
copyFile = open("copyMove.json", mode="w", encoding="utf-8")
while True:
text = file.readline() # 逐行读取
if not text:
break
copyFile.write(text)
file.close()
copyFile.close()
文件操作
文件操作需要导入os模块
rename() 重命名
remove() 删除文件
# 文件重命名
os.rename("copyMove.json", "reNameCopyMove.json")
# 删除文件
os.remove("reNameCopyMove.json")
文本编码格式
- Python2.x 默认是ASCII编码格式
- Python3.x 默认是UTF-8编码格式 (UTF-8是Unicode的一种)
Python2.x 中第一行增加一行代码注释就可以处理Python文件中的中文导致的错误
# *-* coding:utf8 *-* 官方推荐
# coding = utf8
eval函数
eval()函数将字符串当成有效的表达式,并返回计算结果
print(eval("1+1")) # 输出2
eval函数不要滥用,不要直接转换input结果
网络编程
IP地址
目的:用来标记网络上的一台设备(唯一)
dest_ip 目标IP
src_ip 源IP
ip地址的分类
IP地址由四组数字组成 (0-255)
IP地址分类.png端口
dest_port 目标端口
src_port 源端口
用来标识PC的应用进程
知名端口
知名端口0-1023 动态端口从1024-65535
80端口http服务 21端口分配给FTP服务
socket
import socket
# 创建一个socket UDP
udp_socket = socket.socketpair(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口号
udp_socket.bind("端口号")
# 使用套接字收发数据 数据和对方的IP地址以及端口号
udp_socket.sendto("数据", ("192.158.33.23", 8080))
udp_socket.close()
UDP收发收据
同一个套接字可以收发数据
import socket
# UDP聊天器,并保存聊天记录
def main():
# 创建一个socket
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
file = open("chatRecord.txt", mode="a", encoding="utf-8")
while True:
print("UDP聊天器")
print("输入0结束程序")
print("输入1发送数据")
print("输入2接收数据")
input_data = int(input())
if 0 == input_data:
file.close()
break
elif 1 == input_data:
file.write(str(send_data(udp_socket)) + "\n")
elif 2 == input_data:
file.write(str(receive_data(udp_socket)) + "\n")
else:
print("输入错误")
udp_socket.close()
# socket 接收数据
def receive_data(udp_socket):
receive_data = udp_socket.recvfrom(1024)
print("发送者:%s\n发送内容:%s" % (str(receive_data[1]), receive_data[0].decode("gbk")))
return "发送者:%s\n发送内容:%s" % (str(receive_data[1]), receive_data[0].decode("gbk"))
# 使用套接字发送数据
def send_data(udp_socket):
dest_ip = input("请输入对方的ip地址:")
dest_port = int(input("请输入对方的端口号:"))
send_data = input("请输入要聊天的内容:")
udp_socket.sendto(send_data.encode("gbk"), (dest_ip, dest_port))
return str(send_data.encode("utf-8"), encoding="utf-8")
if __name__ == '__main__':
main()
TCP
TCP客户端收发数据
import socket
def main():
# 创建套接字
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_socket.bind(("", 7788))
# 连接服务器
tcp_socket.connect(("192.168.28.90", 8080))
send_data = input("请输入要发送的内容:")
# 发送数据
tcp_socket.send(send_data.encode("gbk"))
# 接收数据
receive_data = tcp_socket.recvfrom(1024)
print("发送者:%s\n发送内容:%s" % (receive_data[1], receive_data[0].decode("gbk")))
# 关闭套接字
tcp_socket.close()
if __name__ == '__main__':
main()
TCP服务端收发数据
import socket
# 创建socket
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定端口信息
tcp_server_socket.bind(("", 7000))
tcp_server_socket.listen(128)
new_client_socket, client_address = tcp_server_socket.accept()
print(client_address)
receive_data = new_client_socket.recv(1024)
print(receive_data.decode("gbk"))
new_client_socket.send("收到信息啦...".encode("gbk"))
new_client_socket.close()
tcp_server_socket.close()
多任务
多线程
线程执行的顺序不确定
调用线程的start()方法时才会创建线程,以及运行线程
import time
import threading
def sing():
for i in range(5):
print("------唱歌--------")
time.sleep(1)
def dance():
for i in range(5):
print("=========跳舞========")
time.sleep(1)
def main():
sing_thread = threading.Thread(target=sing) # 注意这里是要用函数名,不能用函数名()->这个是调用函数
dance_thread = threading.Thread(target=dance)
sing_thread.start()
dance_thread.start()
if __name__ == '__main__':
main()
多线程共享全局变量
全局变量的的修改:
在一个函数中对全局变量进行修改的时候,到底是否需要使用global进行说明,要看是否对全局变量的指向进行了修改
如果修改了指向,即全局变量指向了一个新的地方,那么必须使用global
如果仅仅是修改了指向空间中的数据,此时不用使用global
多线程共享全局变量会导致资源竞争问题
互斥锁
lock = threading.Lock() #创建锁
lock.acquire() # 上锁
lock.release() # 释放锁
网友评论