python7天的总结
------------------------------------------------------------------------------------------------
评价：1、函数 def 自定义行数和内建函数
2、re模块
3、python3和python的去别
4、字典，元组，列表，元组，集合的联系和区别
Python
一、Python介绍：
1、什么是Python？
Python是一门面向对象，解释型的动态类型的编程语言；
Guido van Rossunm 吉多·范罗苏姆 荷兰计算机程序员
2、什么是面向对象？
Python中一切皆为对象，对事物的描述和方法系统的定义为一个类，在这个类中的具体的一个实例就是我们所说的对象
例如：人就是一个类 ------- wf 对象
3、什么是解释型？
Python程序执行时无需先进行编译成二进制代码，直接在执行过程中对语句一条条进行编译
例如：java 装了jdk 编译，python不需要，可以直接编译
4、什么是动态类型？
是指Python程序在运行时可以改变其结构，新的函数可以被引进，已有函数可以被删除
例如：在运行的情况下修改，返回值（存储过程中可以运行以后拿到值，进行运用）
5、Python的特点？
a.特点：简单、易学、免费开源、可扩展性、可移植、高级语言、丰富的类库;
b.应用领域：网页开发、可视化界面开发、系统编程、数据分析、网络爬虫（用的多）、自动化脚本开发（测试用的多）； java，ruby 、数据分析、AI人工智能、大数据、云计算、
6、Python的实际应用：
Youtube、豆瓣网、知乎
7、Python所支持的平台：
windows、linux ,macos
8、Python市面上使用的版本：
Python 2.7.xxxx (现在一些windows都支持,稳定）
Python 3.0.xxxx 现在的主流会越来越流行（目前最新版本3.9）；
差别：版本的高低级而已，就是有一些功能不一样
二、Python中的运算
1，算术运算符
1，+ 加；2，- 减；3，* 乘；4，/ 除；5，% 取模；6，**取幂
7，//取整除'''
注意点：他们的优先级：先乘除后加减
2，赋值运算
1，+= 加法赋值 ；2，-= 减法赋值；3，*= 乘法赋值
4，/= 除法赋值；5，%= 取模赋值；6，**= 幂赋值运算符
3，比较运算符
1，== 等于；2，!= 不等于；3，> 大于；4，< 小于；
5，>= 大于等于；6，<= 小于等于
注意：结果事返回布尔值：falsh ，true
4，逻辑运算符
1，and 与；2，or ；3，或；4，not 非
返回的结果也是布尔值；
5，位运算
1，&按位与
概念：把十进制转化换二进制，上下对应位都是1，则取1，否则取0，结果再转化换十进制
2，按位或
把十进制转换成二进制，上下对应位只要有一个是1，则取1，都为0则取0，结果再转换十进制|
3，按位异^
把十进制转换成二进制，上下对应位不相同，取1，相同取0，结果再转换成十进制
4， 按位取反~
公式 -(a+1) 变量a先加1再取负数
5， 向左移 <<
把变量转换成二进制，左移相应的位数把小数点右移小数位数，结果是小数点左边的二进制转换成十进制
6， 向右移 >>
把变量转换成二进制，右移两位把小数点左移两位，结果是小数点左边的二进制转换成十进制
7，成员运算符：in和not in
返回的也是布尔值；
三、 索引与切片
索引：索引 在公司中一般也叫做下标或者角标
1、我们可以通过索引位读取序列中的指定元素，索引可分为正向索引和负向索引
2、索引的表达式：str[x] 其中x是需要我们自己填写的一个数据，
如：str[1]、str[0]
3、索引中正向索引从0开始，负向索引从-1开始
4、表示不隔位
[起始索引位:结束位:步长值]
切片语法中：包含起始不包含结束，隔位不能为0可以为1，1表示不隔位,从2开始有效果
遍历函数中：包含起始不包含结束，隔位不能为0可以为
print (list(range(10)))
打印的结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2，切片：
1、切片的表达式：str[start_index:end_index:step] 即[开始索引:结束索引:步长值]
2、解释：start_index：开始索引（可以取值）
end_index：结束索引（不能取值）
step：步长 （脚跨了几个楼梯）
3、注意
1）切片中如果步长不写则默认为1
2）切片取值从开始索引到结束索引，且结果不包括结束索引位的值 （取到索引位的前一位）
3）步长从开始索引走起，步长分正负
四、函数
1，字符串函数
capitalize():首字符大写
count():统计具体字符的个数
join():把字符串中的字符按自定义的分隔符连接在一起
split():把字符串通过制定标识符进行分割
strip(ab):删除字符串开头和结尾有a或者b的字符
istrip(ab):删除字符串开头有ab序列的字符
rstrip(ab):删除字符串结尾有ab序列的字符
startswith():判断字符串是否以什么开始
endswith():判断字符串是否以什么结尾
find/rfind():查询指定字符串的下标
replace(substring,newstring,max):替换字符
lower():方法转换字符串所有大写字符为小写字符
upper():字符串中的小写转换为大写
isdigit():判断字符串中是否全为数字
isalpha():判断字符串中是否全为字母
isalnum():判断字符串当中是否全都为数字或者字母或者字母与数字组合
istitle():判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否
isupper()/islower():is开头的就是判断一个字符串是否展示位都是大写后者都是小写
2，列表
索引与切片赋值
list1=[1,88,'test','duoceshi']
list1[0]=666 结果为 [666,88,'test','duoceshi']
list1[2:]=sdada 结果为 [1,88,s,d,a,d,a]
append():添加一个元素
list1=[1,2,3,4,5]
list1.append('a') 结果为 [1,2,3,4,5,a]
extend():连接两个列表
list1=[1,2,3,4,5] list2=[6,7,8]
list1.extend(list2) 结果为 [1,2,3,,5,6,7,8]
insert():在指定位置前插入一个元素
list1=[1,2,3,4,5]
list1.insert(0,'test') 结果为 [test,1,2,3,4,5]
remove():删除元素
list1=[1,2,3,4,5]
list1.remove(2) 结果为 [1,3,4,5]
索引删除值
list1=[1,2,3,4]
del list1[0] 结果为 [2,3,4]
index:在列表中查找元素所对应的索引值
list1=[1,2,3,4]
list1.index(2) 结果为 1
sort：实现列表的升序排列
list1=[1,2,3,4,1]
list.sort() 结果为 [1,1,2,3,4]
sorted:实现降序排列
list1=[1,2,3,4,1]
print(sorted(list1,reverse=Trrue))
结果为 4,3,2,1,1
reverse函数：列表元素反转
list1=[1,2,3,4]
list1.reverse() 结果为 [4,3,2,1]
pop函数
list1=[1,2,3,4]
pirnt(list1.pop(0)） 结果为 1
3，元组
格式：a=(1,2,3)
元组转化为列表
b=list(a)
print(b)
列表转化为元组
a=tuple(b)
print(a)
4，字典
格式：a={'name':'zhangsan','age',18}
1,添加键
a[sex]='nan'
2，取出键
a.keys()
print(a)
3,取出值
a.values()
print(a)
4,取出具体键的值
print(a['name'])
5,字典添加元素
a.setdefault('sex','男')
6，删除字典
del (a)
print(a)
7,删除指定的键，连同值也删除
del(a['name'])
8,字典的遍历
for key in a:
print(key,a[key])
9,用items完成遍历
for key,values in a.items():
print(key,values)
10,POP(key)函数，删除指定键并返回删除的值
print(a.pop('name')) print(a)
结果为[age:18]
11,clear()清空字典所有项
a.clear()
print(a) 结果为[]
12,get(key),通过key获取值，当键不存在，返回none
print(a.get('name')) 结果为[zhangsan]
13,fromkeys函数可以给具体的键指定值
print（{}.fromkeys(['name'],'age')）
print（{}.fromkeys(['name'],'age'),'duoceshi'）
14,popitem
print(a.popitem())
print(a)
15,update()函数利用一个字典变更另一个字典
b={'sex':'nan'}
a.update(b)
print(a)
5，集合
1、可变集合set
list1 = [1,1,1,88,88,'duoceshi','dcs']
set1 = set(list1)
set1.add('dcs')
set1.remove('dcs')
set1.pop() #把最前面这个给删除了
set1.clear()
print (set1)
2、不可变集合frozenset
test = 'hello'
a = frozenset(test)
b = a.copy()
b.add('888') #报错AttributeError: 'frozenset' object has no attribute 'add'
print (b)
五、 模块
1，time模块：
time.time-----1970年到今天过了多少秒
time.ctime------显示当前日期
time.sleep(2)--------休眠
time.asdtime()--------显示当前日期
time.strftime('%Y-%m-%d-%H-%m-%s')
2，random模块
random----随机生成0开头的浮点数
random.random()------随机生成小于1的小数
random.randint(1,5)------随机取一位整数，包含开始
random.randrange(1,100,2)-----根据range函数：(起始，结尾，隔位)，支取1个
random.randrange(0,101,2)---取1-100之间的偶数
a=[1,2,3,4,5,6]
random.choice(a)---------随机取a列表中的一个数字
random.sample(a,3)-----列表中随机取自己定义的个数的值
random.shuffle(a)---------重新打乱a列表的顺序（先洗牌）
print(a)-------再打印
3，String模块
string.digits-----生成0123456789
string.hexdigits------生成0123456789abcdefABCDEF
string.ascii_uppercase----生成26个大写字母
string.ascii_lowercase-------生成26个小写字母
string.ascii_litters------生成26个小写字母和26个大写字母,
4，加密算法
base64位编码
1，加密
a=base64.b64encode(b'123456')
print(a) 结果为 b'MTIzNDU2'
2，解码
c=base64.b64decode(a)
print(b) 结果为 b'123456'
MD5加密
在线加解密：
http://encode.chahuo.com/
https://tool.oschina.net/encrypt?type=2
md5=hashlib.md5()#创建一个对象：md5
md5.update(b'123456')#通md5对象来调用update方法对某个值进行加密处理过
print(md5.hexdigest()) #通过hexdigest将md5加密密码进行十六进制转换输出
结果为：e10adc3949ba59abbe56e057f20f883e
5，os模块
a='D:\\www'
b='qqq.txt'
os.gitcwd()#获取当前操作文件的路径
os.path.isfile(a) #判断是不是文件
os.path.isidr(a) #判断是不是目录
os.path.exists(a) #判断文件或目录是否存在
os.listdir(a) #列出指定目录下的目录或文件
os.path.split(a) #分割文件名与目录
os.path.join(a,b) #连接目录与文件名或目录
os.mkdir(a) #创建一个目录
os.rename(old,new) #更改目录名称
六、判断与循环
1，判断
1、if条件判断语句单分支
if 判断条件：
语句块1……
else：
语句块2……
2、if条件判断语句多分支
if 判断条件1：
语句块1……
elif 判断条件2：
语句块2……
else:
语句块n
2，循环
1， while循环语句
while 条件表达式：
循环体语句
while什么时候进入循环？当循环条件成立时，进入循环
while什么时候退出循环？当循环条件不成立时，退出循环
注意：在写while循环语句时一定要让循环条件发生变化，否认很容易陷入死循环中
2， 循环语句
1、for循环的语法格式如下：
for ... in ...
语句块
2、先熟悉下range()函数：如果需要遍历一个数字序列，可以使用python中内建的函数range()
for i in range (10) #打印0到9、不包含10
for i in range (1,10) #打印1到9、不包含10
for i in range (0,10,2) #打印结果：0，2，4，6，8不包含10
3, continue语句
用法：continue语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
4,break语句
用法：语句会立即退出循环，在其后边的循环代码不会被执行。
七、封装
（1）封装定义：
（2）封装的优点：
2.1封装数据可以很好的保护隐私，（将不需要对外提供的内容都隐藏起来）
2.2 封装方法主要原因是隔离复杂度
2.3 封装提高了代码的复用性。
2.4隐藏对象的属性和实现细节，提供公共方法对其访问
（3）python类的封装两种
3.1公用（共有）：类中的变量和方法公用；他们名称前都没有下划线，公有的变量和方法，在类的外部，内部，以及子类都可以方位
3.2私有：在类中的变量或方法下，下划线__开头命名，则改变量或方法为私用，私有的变量和方法，只能在本类内部使用，类的外部以及子类都五法使用。
私有属性：
格式：__属性名=值 在类的外部不能使用（对象不能调用属性）
私用化封装后的限制：
（1）类 可以访问
（2）类外/对象外 不可访问
（3）子类和子类对象 不可访问
八、继承
继承特性
1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子
类可以继承父类的内容，包括成员变量和成员函数。
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基
类，则另外一个类则为子类也称之为派生类。
九、多态
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象
调用相同的方法，执行产生不同的执行结果。
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是
软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身
包含的属性和方法决定的
==========================================================
案例2：
评价：
1、案例写的详细，但是总结就是笔记
2、总结根据自己的情况，进行总结
一、 Python定义
二、 Python特点
三、 Python的不同点：
胶水语言、输出语句（print）、注释（Ctrl+/、#、’’’）
格式化输出：基本格式：（'%d'%a）
%s :字符串 (采用str()的显示)
%c :单个字符
%d:十进制整数
%i :十进制整数
%o:八进制整数
%x:十六进制整数
%f:浮点数
%% :百分数
常用的运算操作：算术运算（加减乘除）、赋值运算（+=）、比较运算、逻辑运算、位运算、成员运算（in、not in）
四、 索引与切片
索引格式：str[ x]，x为索引号
切片格式：str[start_index:end_index:step]，str[::-1] 反转
常用字符串函数：
1、str.capitalize():实现首字母大写
2. str.count('xx')统计指定字符在当前字符串中出现的次数
3.'_'.join('xx')（拼接函数）自定义分割符，来分割当前的字符串，例如：'@'.join('xx')用@来将xx进行分割
4.分割函数 str.split('xx'):指定当前字符串中的一个字符作为分割符（用，替代字符串中的这个字符），且返回一个列表
例如：str = 'abcdefghigkl'
str1= 'admin:123123'
num = str.split('j')
print (num) 显示结果：['aSDfgh', 'ksl']
5.str.strip('xx'):删除字符串开头和结尾的字符
格式：str.strip('XX')：删除字符串以XX字符开头和结尾的内容
6、str.lstrip('XX')：删除字符串以XX字符开头的内容
print (str.lstrip('a')) 显示结果：bcdefjghigkl
7、str.rstrip('XX')：删除字符串以XX字符结尾的内容
print str.rstrip('l') 显示结果：abcdefjghigk
rstrip 意思：删除末尾字符
8、str.startswith('XX')：判断字符串中以XX字符串开头，如果条件成立返回 TRUE，
否则返回FALSE
print str.startswith('a') 显示结果： True #swith
9、str.endswith('XX')判断字符串中以XX字符串结尾，如果条件成立返回TRUE，否则
# 返回FALSE
print str.endswith('l') 显示结果：True
startswith（self prefix start end）
方法的参数
prefix 开始
end 结束
self 自己本前缀
start 身
10、find、rfind通过具体的值来找到对应值的索引位，
str.find('XX')
从字符串左边开始查找指定的字符串，且返回的是当前字符的索引位，一旦找到第一个将停止查找，如果查找的对象不存在则返回-1
print (str.find('n'))
显示结果：-1
print (str.find('c')) # 左边开始查 显示结果：2 显示第一个的下标，没有显示-1
11、str.rfind('XX')从字符串右边开始查找指定的字符串，且返回的是当前字符的索引位，一旦找到第一个将停止查找，如果查找的对象不存在则返回-1
print (str.rfind('k'))
显示结果：11 # 左边开始查<br>注意：取得索引都是正向索引 ，注意当出现多个同样的字符find和rfind 是不同的
12、str.replace('XX','YY')替换指定的字符串，且可以指定替换次数
print (str.replace('c', 'dcs'))
显示结果：abdcsdefjghigkl
13、replace()替换字符串中的字符 ：replace(substring,newstring,max)
str.replace('XX', 'YY', 1) #
方法中的1表示将指定字符替换的次数，从左到右开
始替换 --这里次数为1的话只会替换第一个发现的字母XX改下：
str = 'asDfghjksl'
print (str.replace('c', 'dcs', 2))
显示结果：
14、str.lower()将字符串中的所有大写字母改为小写print (str.lower())
显示结果（小写）：asdfghjksl
15、str.upper()将字符串中的所有小写字母改为大写
print (str.upper()) 显示结果：ABCDEFJGHIGKL
字符串判断方法
mtehod 方法
以下都是字符串的判断，结果只有true or false
17、name.isalnum() 判断字符串是否是字母或者数字 # alnum字母和数字，小写字母。
name = "1123abcdefg"
print(name.isalnum()) 判断字符串是否是字母
显示结果：ture
print (name.isdigit()) 判断字符串是否是数字 # digit
显示结果：flse
18、print (name.islower()) 判断字符串是否是小写
显示结果：ture
19、print (name.isupper()) 判断字符串是否是大写,有小写就显示false，只有大写字母和汉字仍为true
显示结果：flse
20、name.isspace() 判断字符串是否全部由空格组成。
五、列表、元组、字典及其常用操作
列表（list）
一、定义
1.list=[1,2,3,4,5]
2.通过list（）进行转换
3.对列表操作：
通过索引赋值：格式 列表名[ 索引]=“ 新值”
通过切片赋值：格式 列表名[ 索引：]=“ 新值”
二、函数
1、赋值
第一种：赋值（索引方式）
a=[1,2,3,4,5,6] b=['大'，‘家’，‘好’]
a[4]='yy'
结果：[1,2,3,4,'yy',6]
注意点：1.把原来对应索引位置替换成新的值
第二种：
a[2:]='蔡瑞峰为什么这么帅'
结果：[1,2,'蔡','瑞','峰','为','什','么','这','么','帅'](从索引号为2开始被后面的字符替代)
2、append 添加函数（默认添加在列表最后）
格式：变量名.append('hello')
举例：a.append('hello')
结果：[1,2,3,4,5,6,'hello']
3、extend 拼接函数（两个列表的拼接）
格式：变量名1.extend(变量名2)
举例：a.extend(b) (将b拼接在a后面)
4、insert 插入函数
1、根据索引值插入值：（如果索引已存在插入，之前的索引值+1， 不存在出入就插入指定索引值，超出索引值也是在最后显示）
第一种情况：超出的索引值
|
s =[1,2,3,4,5] #定义一个列表 s.insert(10,'hello') #给索引值为10的位置在最后一位 print(s) #[ 1, 2, 3, 4, 5,'hello']<br>备注:超出索引范围，都默认显示在列表的最后一位 |
第二种情况：存在的索引值
|
s =[1,2,3,4,5] #定义一个列表 s.insert(0,'hello') #给索引值为0的位置插入一个具体的值 print(s) #['hello', 1, 2, 3, 4, 5]<br>备注：插入的值是当前指定的索引，原列表中的索引加1或（往后推一位） |
第三种情况：负向索引
|
s =[1,2,3,4,5,6] #定义一个列表 s.insert(-1,'hello') #给索引值为0的位置插入一个具体的值 print(s) #[1, 2, 3, 4,5,'hello', 6] |
5、remove 删除
方法一：删除的是具体的值
第一种情况：有对应的值，有且只有一个
c=[1,2,3,4,5,6,"a"]
c.remove(2)
print(c)
打印结果： [1, 3, 4, 5, 6, 'a']
第二种情况： 删除有多个一样的值，只删除第一个
|
l = ['c', 1, 2, 3, 4,'c' ,5, 6, 'c'] # 定义一个列表 l.remove("c") # 移除l列表中对应的具体值 print(l) #显示结果 [1, 2, 3, 4, 'c', 5, 6, 'c']<br>备注：多个同样的值，从左开始删除第一个值， |
# 移除l列表中对应的具体值
第三种情况：删除不存在的值，报错，不在删除的列表中
|
l = ['c', 1, 2, 3, 4, 5, 6, 's'] # 定义一个列表 l.remove("a") # 移除l列表中对应的具体值 print(l) # 显示结果：报错 删除的内容不存在列表中 |
6、del 删除
方法二：del 删除
第一种情况：
del 通过索引 删除列表种对应的元素
|
# l1 =[1,2,3,4,5] #定义一个列表 # del l1[4] #删除对应列表中对应的索引值对应的值 # print(l1) #打印结果：[1, 2, 3, 4] |
第二种情况: 超出索引值，删除列表是错误的
|
l1 =[1,2,3,4,5] #定义一个列表 del l1[6] #删除对应列表中对应的索引值对应的值 print(l1) #显示结果：list assignment index out of range<br>备注：报错，列表索引超出范围 |
7、sort 升序
|
场景1、l1 =[5,4,3,2,1] #定义一个列表 l1.sort() #通过sort来对列表进行升序排序 print(l1) #[1, 2, 3, 4, 5] |
|
<br><br>场景二：字符和数值在一个列表中不能进行排序，报错 |
c=[1,2,"a",3,4,3,5,6,"a"]
c.sort()
print (c)
报错TypeError: '<' not supported between instances of 'str' and 'int'
场景三：列表中出现多个相同的数值排序（根据数值的大小并列）
d=[1,2,9,4,3,6,6,5,6]
d.sort()
print(d)
打印结果：[1, 2, 3, 4, 5, 6, 6, 6, 9]
8、sorted 降序
sorted要配合reverse一起使用才能实现升序与降序
格式：sorted（变量名，reverse=True）降序
sorted（变量名，reverse=False）升序
9、reverse 反转
格式：变量名.reverse（）（实现列表中元素反向排列）
10、pop 删除（默认删除最后一个元素，也可以通过索引来删除）
格式：变量名.pop()
变量名.pop(索引号)
10、场景一：index根据列表中具体的值得出索引值
d=[1,2,9,4,3,6,6,5,6]
print(d.index(2))
打印结果：1
------------------------------------------------------------------------------------------------------------
元组（tuple）
一、定义
元组定义后由于不可直接修改则相对于代码来说要更加安全
1.a=（1,1,2,3,4,5,）
2.通过tuple（）进行转换
3.tuple(a)=tuple(b)+tuple(c) 元组的拼接
注意：元组不能进行元素的修改与添加，因此要修改元祖内的数据需要通过list（tuple）将元组转化为列表
-------------------------------------------------------------------------------------------------------------------------------------------------------
字典（dict）
|
1 python中的字典：dict类型 2 键值对组成 3 键是唯一，值可以不唯一 4 {} 英文的大括号 也叫花括号 5 字典中键值是一个整体，如有多个键值对要用英文的,逗号隔开 6 整数类型不需要加单双引号外，其它都需要加单双引号 7 键和值用英文的:冒号 比如：name:zhangsan （1）定义一个字典d ={'name':'zhangsan','age':18} #定义一个字典print(type(d)) <class 'dict'>字典的类型 |
print(d) #打印结果为：{'name': 'zhangsan', 'age': 18}
（2）列表转换成字典步骤 重点：（使用dict 就可以转换）
第一步：定义一个列表
l =[('name','zhangsan'),('age',18)]
第二步：使用dict 将列表转换成字典
di_ct=dict(l)#将列表转换成为字典
第三步：查看字典的类型
print(type(di_ct)) #<class 'dict'>字典类型
第四步：在打印字典
print(di_ct) #{'name': 'zhangsan', 'age': 18}
备注：字典转换是键与值一组，所以是2个值一组
（3）字典中添加键值对： 格式：变量名[键] =值
注意：字典中添加新的的键和值
d ={'name':'zhangsan','age':18}#定义一个字典
d['scroe']=100
print(d) #{'name': 'zhangsan', 'age': 18, 'scroe': 100}
（4）字典中有键，替换值（键不变，值变）
c= {'name': 'zhangsan', 'age': '18'}
c['name'] = 200
print(c) # 打印结果：{'name': 200, 'age': '18'}
小结：《1》、给字典中增加一个键值对：如原字典内没有相同的键值对则新增一个
《2》、如原有字典中有相同的键，则会将对于的键的值进行重新赋值''
3、通过keys取出对应的键
|
d ={'name':'lis','age':18} #定义一个字典 print(d.keys()) #(['name', 'age']) # 通过keys来取出对应的键 print(type(d.keys())) #<class 'dict_keys'> |
4、通过values 取出字典中对应的值
|
v={'name':'lis','age':18} #定义一个字典 print(v.values()) #['lis', 18] |
5、通过键来获取对应键的值
|
k ={'name':'lisi','age':18} #定义一个字典 print(k['name']) #lisi |
6、6.1添加设置默认键值setdefault
mr ={'name':'lis','age':18} #定义一个字典6.1默认值不存在的情况下，直接添加键值mr.setdefault('scroe',100)
|
1 2 3 4 5 6 |
<em id="__mceDel"><em id="__mceDel">print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br><br>6.2 已有键值，在使用默认键值不会进行修改，或者增加 mr.setdefault('name','zhangsan') print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br>备注：已经存在的值的优先级>默认值<br>6.3 直接修改 值，显示最新修改值 （修改默认值优先级小于直接添加的字典值）<br> mr['name']='wangwu' print(mr) #{'name': 'wangwu', 'age': 18, 'scroe': 100}<br><br><br> </em></em> |
7、删除键：（删除键，值也没有了）
|
1 2 3 |
dellkey={'name':'zhangsan','age':18} del dellkey[ 'name'] print (dellkey)<br>注意点：键和值都要用引号，除数值外<br><br> |
8、使用for 循环获取key
|
1 2 3 |
d ={'name':'zhangsan','age':18} for k in d: print(k) #拿到的是：键 值不拿 |
9、使用for循环获取key，values
|
1 2 3 |
s ={'name':'zhangsan','age':18} for k in s: print(k,s[k]) |
10、# 通过items()方法来获取对应键值对
|
1 2 3 |
t ={'name':'zhangsan','age':18} for k,v in t.items(): print(k,v) |
11、'通过pop函数删除指定的键，打印返回对应键的值'''
方法一：pop删除指定的键，返回对应的值
|
1 2 |
d2 ={'name':'zhangsan','age':18} print(d2.pop('name')) #zhangsan |
方法二：popitem在字典删除键值对，一般默认在末尾
|
1 2 |
d ={'name':'zhangsan','age':18,'':100} print(d.popitem()) #('', 100)<br>备注：打印结果：字典中最后一个键值 |
12、clear 来清空当前字典中的键值对，返回一个空字典
|
1 2 3 |
d3 ={'name':'zhangsan','age':18} d3.clear() #通过clear()来清空当前字典中的键值对 print(d3) # 打印结果：{}清空后返回就是一个空字典<br> |
13、get ，get通过键获取对应的值
|
1 2 3 4 5 6 7 |
d ={'name':'zhangsan','age':18,'':100} print(d) #{'name': 'zhangsan', 'age': 18, '': 100} print(d.get('name')) #zhangsan #通过键获取值 print(d.get('')) #100 print(d.get('age')) #18 print(d.get('score')) #None #通过不存在的键，返回的是none print(d.get(100)) #None #通过值去获取，返回时的none |
14、快速生成一个新字典的方法fromkeys
方法一：
第一种情况：生成一个新的字典的键
print （{ }.fromkeys(['name','age'])） #{'name': None, 'age': None}
第二种情况：生成一个字典的键和值
print({}.fromkeys(['name','age'],'a')) #{'name': 'a', 'age': 'a'}
方法三：快速生成字典，并赋同样的值
|
1 2 |
d={'name':'zhang','age':18} print(d.fromkeys(['name','age'],'c')) #{'name': 'c', 'age': 'c'} |
15、update 方法 将多个字典合并
|
1 2 3 4 |
d1 ={'name':'zhangsan','age':18} #定义一个字典 d2={'scroe':100} #定义一个字典 d1.update(d2) #通过update方法将d1字典和d2字典进行合并 print(d1) #{'name': 'zhangsan', 'age': 18, 'scroe': 100}<br>备注：合并字典以后，在d1表中 |
16、copy 复制字典
|
1 2 3 4 |
s={"name":"zhangsan","age":15} c= s.copy() print (c) print (s) |
17、del删除字典
|
1 2 3 4 5 6 7 8 |
#场景一： d={"name":"lixi","age":18} del d #场景二：删除键 d={"name":"lixi","age":18} print(d) # del (d["name"]) # print(d) |
备注：has_key 在python2中有，在python3中不存在
六、 Python中的语句
- 输入语句input（‘xxx’），输出语句：print（‘xxx’）
- If语句：单分支，多分支，if嵌套
- While循环语句
- For循环语句
- Continue语句（跳过指定条件，继续执行后面）
- Break语句（退出循环，不再执行break后面的内容）
七、 Python中的函数
1、函数：一个工具，随调随用
优点：
(1)降低代码冗余
(2)增加代码的复用性，提高开发效率
(3)提高程序扩展性
(3)函数有两个阶段：定义阶段，调用阶段。
(4)定义时：只检查函数体内代码语法，不执行函数体内代码。
(5)比如：我们存储的过程，就是把所有的语句块，调用
(6)封装：就是把代码片段放在函数当中
2、自定义函数
def 自定义函数名（）：
函数体
函数 的调用格式 函数名（）
举例：def fun（）：
print（‘请输入密码：’）
调用：fun（）
调试时调用多个函数：if __name__=='__main__'：
从其他模块调用：import aa (导入aa模块）
aa.fun( )（调用aa模块的fun函数）
3、可变长元组（*list）与可变长字典（**dict）
4、全局变量与局部变量
5、return（函数的返回值）
6、内置函数（format、zip、open、with open、abs、sum、map）
6.1format（格式化输出函数）
a ='{}'.format('hello','ni','hao')
print(a) #打印结果 hello
6.2 zip（打包函数）
打包：zip（a，b） print（list（zip（a，b）））
解压：s，c=zip（*zip（a，b）） print（list（s））
6.3 open（打开与编辑文件）
open完整的语法格式为：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需，文件路径（相对或者绝对路径）。
6.4 with open（open的扩展）
url =r'C:\Users\Administrator\PycharmProjects\untitled1\requester\ss.py'
with open(url,'r',encoding='utf-8')as o:
a=o.read()
print(a)
八、 Python中的模块
- 模块的导入（import）
- Time模块（时间的显示）
time.time()(显示从1970年到现在一共经历的秒数)
time.ctime()（显示当前实时时间）
time.sleep()（休眠，括号内加上数字表示休眠多少秒后再执行）
time.strftime()（自定义时间格式：%Y-%m-%d-%H:%M:%S）
time.asctime()(转换为asc码形式显示时间)
3、random模块
random.random() 随机生成0开头的浮点数
random.randint(1,4) 随机取一个在1-4范围内的数（不包含4）
random.sample(a,4) 在a中随机抽取4个数生成一个列表
random.randrange() 递增随机取一个值
random.choice(a) 在a列表中随机取一个值
random.shuffle（） 随机洗牌（将列表中的所有元素随机调 动输出）
- string模块（字符串）
string.digits 生成0-9的整数
string.hexdigits 生成0-9的整数+大小写的a-f和A-F
string.ascii_uppercase 生成26个大写字母
string.ascii_lowercase 生成26个小写字母
4、加密与解密
5、OS 模块（对于目录文件路径常用的模块）
OS.getcwd() 获取当前文件对应的目录（相对路径）
os.path.isfile(a_path) 判断当前是否为文件，返回布尔值
OS.path.isdir() 判断是否为目录
os.path.exists(a_path) 判断文件（目录）是否存在
os.mkdir() 创建目录mkdir（a，755）注意：目要设置权限，755或者777
os.remove(a_path) 删除文件（无法删除目录）
os.listdir(a_path) 获取当前目录下所有的文件和目录
os.path.split(a_path) 对某个路径进行分割，要求：把路径 分隔以后，再通过索引取出分隔后的值，在使用得到的值进行拼接，拼接成新的路径
例如：
#第一步先使用split分割 a_path ="D:\\bao" print(os.path.split(a_path)) # 第二步在根据索引取值 path=os.path.split(a_path)[0] #第三步在拼接 b_path=os.path.join(path,11.py) print(b_path)
os.path.abspath(a_path) 通过名称获取当前名称对应的路径（绝对路径）
os.rename(old_path,new_path) 重命名目录和文件
6、re模块（正则匹配）
# 预定义字符集匹配：
\ d: 数字0-9
\D: 非数字
\s: 空白字符
\n: 换行符
\w: 匹配字母数字
\W: 匹配非字母数字
^：表示的匹配字符以什么开头
$：表示的匹配字符以什么结尾
*：匹配*前面的字符0次或n次 #eg：ab（* 能匹配a 匹配ab 匹配abb ）
+：匹配+前面的字符1次或n次
?：匹配?前面的字符0次或1次
{m}：匹配前一个字符m次
{m,n}：匹配前一个字符m到n次(包括n次)，m或n可以省略，mn都是
1、findall #从第一个字符开始查找，找到全部相关匹配为止，找不到返回一个空列表[]
2、compile #编译模式生成对象，找到全部相关匹配为止，找不到返回一个列表[]
3、match # 从第一个字符开始匹配，如果第一个字符不是要匹配的类型、则匹配失败并报错# 注意：如果规则带了'+'，则匹配1次或者多次，无' +'只匹配一次
4、search #从第一个字符开始查找、一找到就返回第一个字符串，找到就不往下找，找不到则报错
九、类与对象
1、面向对象的基本概念：类（所有具有相同属性和方法的对象的集合）、对象（通过类定义的数据结构实例）、方法（类中定义的函数）、类变量（实例中对象公用的，定义在类中且在函数体之外）、实例变量（用self修饰的变量）
2、定义与使用类
定义格式：class people（）
Def __init__(self,name)
创建对象：p=people(‘xx’)
3、类中的实例方法、动态方法、静态方法
实例方法
定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
调用：只能由实例对象调用。
动态方法（类方法classmethod）
定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；
调用：实例对象和类对象都可以调用。
静态方法（staticmethod）
定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
调用：实例对象和类对象都可以调用。
4、类的三大特性（封装特性、继承特性、多态特性）
===============================================================
