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  # 左边开始查
注意：取得索引都是正向索引  ，注意当出现多个同样的字符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']
备注:超出索引范围，都默认显示在列表的最后一位

第二种情况：存在的索引值

s =[1,2,3,4,5] #定义一个列表

s.insert(0,'hello') #给索引值为0的位置插入一个具体的值

print(s) #['hello', 1, 2, 3, 4, 5]
备注：插入的值是当前指定的索引，原列表中的索引加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']
备注：多个同样的值，从左开始删除第一个值，

# 移除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
备注：报错，列表索引超出范围

7、sort        升序

场景1、l1 =[5,4,3,2,1] #定义一个列表

l1.sort() #通过sort来对列表进行升序排序

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

场景二：字符和数值在一个列表中不能进行排序，报错

c=[1,2,"a",3,4,3,5,6,"a"]

c.sort()

print (c)

报错TypeError: '

场景三：列表中出现多个相同的数值排序(根据数值的大小并列)

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))

字典的类型

print(d) #打印结果为：{'name': 'zhangsan', 'age': 18}

(2)列表转换成字典步骤 重点：(使用dict 就可以转换)

第一步：定义一个列表

l =[('name','zhangsan'),('age',18)]

第二步：使用dict 将列表转换成字典

di_ct=dict(l)#将列表转换成为字典

第三步：查看字典的类型

print(type(di_ct)) #字典类型

第四步：在打印字典

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())) #

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

print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}
6.2 已有键值，在使用默认键值不会进行修改，或者增加

mr.setdefault('name','zhangsan')

print(mr) #{'name': 'lis', 'age':  18, 'scroe': 100}
备注：已经存在的值的优先级>默认值
6.3 直接修改 值，显示最新修改值  (修改默认值优先级小于直接添加的字典值)

mr['name']='wangwu'

print(mr) #{'name': 'wangwu', 'age': 18, 'scroe': 100}

7、删除键：(删除键，值也没有了)

1

2

3

dellkey={'name':'zhangsan','age':18}

del dellkey[ 'name']

print (dellkey)
注意点：键和值都要用引号，除数值外

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)
备注：打印结果：字典中最后一个键值

12、clear  来清空当前字典中的键值对，返回一个空字典

1

2

3

d3 ={'name':'zhangsan','age':18}

d3.clear() #通过clear()来清空当前字典中的键值对

print(d3) #  打印结果：{}清空后返回就是一个空字典

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}
备注：合并字典以后，在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、类的三大特性(封装特性、继承特性、多态特性)

===============================================================