PYTHON

1. python

1.cmd（命令提示符）中输入python，进行程序编写

2.声明一个python文件，然后在该目录下python xx.py执行python文件

3.pycharm编译

1
print("hello world")
0x01: pycharm以及注释
1
2
3
4
#

'''
'''
0x02: 数据类型
1
2
3
#查询变量数据类型
a = 10
print(type(a))
1
2
3
4
5
6
7
8
9
10
11
12
数字（int、float、complex、bool）

字符串（str）

字典（dict）
a = {}

元组（Tuple）
b = ()

列表（list）
c = []

变量命名规则和c差不多

命名规范

0x03:python基本运算符
1
2
3
算术运算符：
+ - * / % ** 
地板除：//
1
2
比较运算符：
== < > <= >= !=
1
2
3
#逻辑运算符：
#and or not
and 条件必须都为true返回true
1
2
优先级：
()->not->and->or
0x04:
输入与输出

输出：

1
2
3
name = '张三'
sex = 'male'
print('我的名字是%s，是%s'%(name,sex))
1
2
3
4
格式化输出；
使用 format
name = 'yuer'
print('name:{}'.format(name))

输入：

1
name = input('pleast input your name:')

2.判断语句与循环控制

0x01:if-else语句

流程：计算机执行代码的顺序

流程控制：对计算机执行代码顺序的管理，只有流程控制才能实现在开发当中的业务逻辑

流程控制分类：顺序流程、选择（分支）流程、循环流程

选择流程：

1
2
3
4
5
6
7
8
9
10
11
12
13
双分支：
if 条件表达式:
    ………………
else:
    ………………

多分支：
if 条件表达式:
    ………………
elif 条件表达式:
    ………………
else:
    ………………

条件表达式：比较运算符/逻辑运算符/复合运算符

1
2
3
4
5
6
7
a = int(input("请输入数字："))
if a >= 1:
	print("true")
elif a == 0:
	print("false")
else:
	print("a little true")
0x02:while循环

循环流程·：

1
2
3
4
5
while 条件表达式:
	逻辑代码
	
for ... in 可迭代集合对象:
	逻辑代码

while语法特点：

1.循环必须有一个初始值

2.必须有条件表达式

3.要有自增或自减变量，否则会死循环

4.循环次数不确定，依靠循环条件结束

5.主要用于判断

1
2
while true:
	python代码段
0x03:for循环
1
2
3
4
格式：
for 临时变量 in 字符串、列表等:
	执行代码
	……

语法特点：

1.遍历操作，依次地取集合容器中的每个值

适用于已知的循环次数（可迭代对象的遍历

eg：

1
2
3
4
tags='abcdefg'  #字符串类型本身就是一个字符类型的集合
for item in tags:
	print(item)
	pass

range函数 此函数可以生成一个数据集合列表

1
2
3
range函数使用：
range(起始值:结束:步长) 步长不能为0
range(1,100,1)
1
2
3
4
5
sum = 0
for i in range(1,101):
    sum += i
    pass
print(sum)

for—else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
k = key
for i in range(1,10):
	if i == k:
		break
	pass
else:
	print("未找到key")
    pass
############################################################
username = 'yuer'
password = '123'
for i in range(3):
    zh = input("账号：")
    pd = input("密码：")
    if zh == username and pd == password:
        print("登陆成功")
        break
        pass
    pass
else:
    print("账号或者密码错误，请重新登录")
    pass
0x04:break、continue
1
2
break退出循环
continue跳过本次循环，继续下一次循环

3.高级数据类型

1
2
3
4
5
6
7
8
9
10
序列：一组按照顺序排序的值（数据集合
在python中存在三种内置的序列类型：字符串、列表、元组

优点：可以支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端

#切片是指截取字符串中的任意一段内容。
#使用方法：[起始下标:介绍下标:步长]切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符

下标会越界，切片不会
0x01:字符串

常用方法：

capitalize() 首字母变大写
endswith()/startswith() 是否->结束/开始
id() 查看变量内存地址
find() 检测x是否在字符串中
index() 检测x是否在字符串中
isalnum() 判断是否是字母和数字
isalpha() 判断是否是字母
isdigit() 判断是否是数字
islower() 判断是否是小写
join() 循环取出所有值得用xx去连接
lower()/upper() 大小写转换
swapcase() 大写变小写，小写变大写
lstrip()/rstrip()/strip() 移除左/右/两侧空白
split() 切割字符串
title() 把每个单词的首字母变成大写
replace(old,new,count=None) 替换字符，count为替换个数，无count表示全部替换
count() 统计出现的次数
1.常用方法使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#capitalize()
name = 'yuer'
print("my name is {}".format(name.capitalize()))
print("my name is %s"%name.capitalize())

#strip()
a = '  yuer  '
b = a.strip()
c = a.lstrip()
d = a.rstrip()

#id()
a = '123'
b = a #对内存地址进行复制
print(id(a))
print(id(b))

#find()  index()
#find如果没有找到就返回-1
#find如果没有找到就会报错
a = 'cookie'
print(a.find('o'))     #1 第一次出现的下标，下标从0开始
print(a.index('o'))

#startswith() endswith()
a = 'yuer'
print(a.startswith('y'))  #True
print(a.endswith('r'))  #True

#lower()/upper()
#对全体进行操作
a = 'CooKie'
print(a.lower())
print(a.upper())
2.切片操作
1
2
3
4
5
6
7
8
str = 'we need a pwner'
# slice [start:end:step]
print(str) #输出完整数据
print(str[0]) #某个数据
print(str[3:6])  # nee 结束点不被包含 左闭右开
print(str[3:])  #取到最后
print(str[:2])  #取前两位
print(str[::-1]) #倒序输出 负号表示方向，从右边往左遍历
0x02:列表
1
2
3
4
5
6
7
有序的数据集合
1.可以随时添加、删除和修改
2.数据是可以变化的（数据项可以变化，但地址不会改变
3.用[]表示列表类型，数据项之间用逗号分隔，注意：数据项可以是任何类型的数据
4.支持索引和切片来进行操作

用for循环可对列表进行遍历

列表定义：

1
2
li = []
print(type(li))

方法：

append 在列表后面追加元素
len 输出列表中元素个数
count 统计元素出现的次数
extend 扩展，相当于批量添加
index 获取指定元素索引号
insert 在指定位置插入
pop 删除最后一个元素
remove 移除左边找到的第一个元素
reverse 反转列表
sort 列表排序
1.常用方法使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 查找 支持切片
li = [1,2,3,'yuer','123']
print(li)  #输出完成的列表
print(li[0]) #输出第一个元素
print(li[1:4]) #输出第二个到第四个元素
print(li[2:]) #第三个元素到最后
print(li[::-1])  #倒序输出
print(li*2)  #多次输出列表中的元素
print(li.index(20))  #返回查找元素的下标
print(li.index())
# index(元素,start,end)  start和end都是下标值

# 增加 append() insert() extend()
li = [1,2,3,'yuer','123']
li.append(['yer'])  #追加的是列表
li.append('111') #追加元素的时候只能追加一个
li.insert(1,'插入数据')  #在指定位置插入元素
d = list(range(11))  #强制转换为list对象
li.extend(d) #扩展可以将其他列表中的元素增加到进行操作的列表之中 批量增加
li.extend(['123',234,'dc']) #同上

#修改  
li = [1,2,3,'yuer','123']
li[0] = 'tom' #可以直接修改 数据类型没有要求

#删除 pop() del remove()
li2 = list(range(10,51))
del li2[0]  #删除第一位元素
del li2[1:3] #利用切片进行批量删除元素
li2.remove(20) #移除指定的元素
li2.pop(1)  #移除指定下标的元素

0x03:元组

tuple

1
2
3
4
5
6
元组：是一种不可变的序列，在创建之后不能做任何的修改
1.不可变
2.用()创建元组类型，数据项用逗号分隔
3.可以是任何的类型
4.当元组中只有一个元素时，要加上逗号，不然解释器会把元组当作元素处理
5.支持切片操作

元组创建：

1
2
a = ('123',123,'yuer',['111',111,'yer'],('1',2))
print(type(a))  #tuple
1.简单操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#查询==>for循环 索引 切片
a = ('123',123,'yuer',['111',111,'yer'],('1',2))
for i in a:
    print(i,end=' ')
    pass

print(a[0])
print(a[1:3])
print(a[::-1])  #倒叙输出 从右往左下标4相当于从左往右下标-1
print(type(a[3])) #列表 虽然元组不可修改但是可以对元组中的列表进行修改

#内置方法 count  统计元素在元组中出现的次数
a = ('123',123,'yuer',['111',111,'yer'],('1',2))
print(a.count('yuer')) #1

#内置方法 index  查找指定元素在元组中的下标索引
a = ('123',123,'yuer',['111',111,'yer'],('1',2))
print(a.index('yuer'))  #2
1
2
3
4
5
6
tupleA = ()  #空元组
print(id(tupleA))
tupleA = ('adcd',11,22)
print(id(tupleA))

#两次的地址是不一样的 因为元组是不可修改的
0x04:字典
1
2
3
4
5
6
1.可以存储任意对象，以键值对的形式创建的{'key':'value'}利用大括号包裹，数据项用逗号分隔
2.字典中找某个元素时，是根据键、值字典的每个元素由2部分组成
3.在我们不确定字典中是否存在某个键而又想获取其值的时候，可以使用get方法，还可以设置默认值
4.字典中键不可重复，值可重复（如果有重复的键，后者会覆盖前者
5.字典的键只能是不可变类型：数字、字符串、元组等
6.不是序列类型，没有下标概念，不能使用索引，是python内置的高级数据类型
1.常用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#创建字典
a = {}
print(type(a))

#增加数据 
a = {}
a['name'] = 'yuer' #   key:value
print(a)

#元素格式
a = {'name':'yuer','sex':'male'}
print(len(a))  # 2

#获取元素 keys() values() items()
a = {'name':'yuer','sex':'male'}
print(a['name']) #只能通过键获取值，并且值可以修改
print(a.keys())  #获取所有的键
print(a.values()) #获取值
print(a.items())  #获取所有的键值对，也可以通过for循环遍历

#修改数据 update() add[]
a = {'name':'yuer','sex':'male'}
a.update({'name':'cookie'}) #更新数据 
a.update({'age':'18'})  #增加数据
a.add['name'] = 'cookie'
print(a)

#删除数据 del pop
a = {'name':'yuer','sex':'male'}
del a['name']   #删除指定键
a.pop('name')  #删除指定键

#排序操作 sorted()
print(sorted(a.items(),key=lambda d:d[0])) #按照key排序
print(sorted(a.items(),key=lambda d:d[1])) #按value排序，但是数据类型要一致
# 在函数sorted(a.items(), key = lambda d:d[1])中，第一个参数传给第二个参数“键-键值”，第二个参数取出其中的键([0])或键值(1])
0x05:公用方法
1.合并操作 +

使用字符串、列表、元组

1
2
3
4
5
6
7
8
9
10
11
a = 'yuer'
b = '123'
print(a+b)   #yuer123

listA = [1,2,3]
listB = [7,8,9]
print(listA+listB)  #[1, 2, 3, 7, 8, 9]

tupleA = (1,2,3)
tupleB = (4,5,6)
print(tupleA+tupleB)  #(1, 2, 3, 4, 5, 6)
2.复制 *

字符串、列表、元组

1
2
3
4
5
6
7
8
a = 'yuer'
print(a*3)

listA = [1,2,3]
print(listA*3)

tupleA = (1,2,3)
print(tupleA*3)
3.in判断元素是否存在

字符串、列表、元组、字典

1
2
3
4
5
a = 'yuer'
print('a' in a)  #bool值

dic = {'name':'yuer'}
print('age' in dic) #进行键查询

4.python函数基础

0x01:函数基础

函数定义：

1
2
3
4
5
def 关键字 小括号 :
	代码块
	
def 函数名(参数列表):
	代码块

函数说明文档：

函数内容的第一行可以用字符串进行函数说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def inform():
    '''
    用于输出信息
    :return:
    '''
    print("my name is {}".format('yuer'))
    print("my age is {}".format(11))
    pass

# 输出不同的信息，用参数实现
def inform(name,age):
    '''
    自我介绍模板
    '''
    print("my name is {}".format(name))
    print("my age is {}".format(age))
    pass
0x02:函数参数

参数分类：

必选参数、默认参数（缺省参数）、可选参数、关键字参数

1
2
3
4
5
参数：函数为了实现某项特定功能，进而为了得到实现功能所需要的数据，为了得到外部数据
必选参数：在函数调用的时候必须要赋值
默认参数：

# 定义函数学习参数
#必选参数
1
2
3
4
5
6
7
8
def sum(a,b):  
    #a,b为形参，在定义的时候不占内存地址
    sum = a + b
    print(sum)
    pass
a,b = map(int,input().split())
sum(a,b) #调用参数 这里的a,b是实参，占用内存地址
sum()  #直接调用会报错，必须要有两个参数，因此是必选参数
#默认参数
1
2
3
4
5
#始终存在于参数列表中的尾部
def sum(a=20,b=30):
    print('默认参数的使用={}'.format(a+b))
    pass
sum()  #可直接调用，若有参数的时候对个数不强制，但如果只有一个参数的时候默认赋值给前面的形参
#可选参数（不定长参数

接受的数据是一个元组类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#当参数的个数不确定时使用，比较灵活
def sum(*args):
    '''
    可变长的参数类型
    累加
    '''
    print(args)
    pass
sum(1)  
sum(1,2)  #以元组形式进行输出
#for循环实现多参数遍历
def sum(*args):
	sum = 0
   	 	for i in args:
        	sum += i
        	pass
    print(sum)
    pass
#关键字可变参数

接受的数据是字典类型

1
2
3
4
5
6
7
8
9
10
11
#  ** 来定义

#在函数体内 参数关键字是一个字典类型，key是一个字符串
def keyFunc(**kwargs):
    print(kwargs)
    pass
keyFunct(1,2,3) #报错
a = {'name':'yuer','age':'11'}
keyFunc() #空字典
keyFunc(**a)  #直接传字典的时候要加上 **
keyFunc(name='peter',age=18) #应该以键值对的形式传参
#组合使用
1
2
3
4
5
6
7
def comx1(*args,**kwargs):
    print(args)
    print(kwargs)
    pass
comx1(age=18)  

#可选参数必须放在关键字可选参数之前
0x03:函数返回值

*函数需要返回多个结果时，将要返回的值用逗号隔开，最终会返回一个包含所有返回值的元组

1
2
3
1.函数执行完以后会返回一个对象，如果函数的内部有return这个关键字，就可以返回实际的值，否则返回None
2.可以返回任意类型，取决于return关键字后面的元素的类型
3.给调用方返回数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def sum(a,b):
    sum = a+b
    return sum
a,b = map(int,input().split())
print('a+b={}'.format(sum(a,b)))

def hanshu():
    return 1,2,3
print(hanshu())  #以元组类型输出

def hanshu():
    return {'name':'yuer'}
print(hanshu())  #以字典类型输出
print(type(hanshu()))  #字典
0x04:函数嵌套
1
2
3
4
5
6
7
8
9
10
11
12
def fun1():
    print("-----start------")
    print("-----执行代码省略-----")
    print("-----end-----")
    pass
def fun2():
    print("-----start-----")
    fun1()
    print("-----end-----")
    pass

#在调用fun2函数的时候会调用到fun1函数，fun1函数执行完毕之后继续执行之后的代码
1
2
3
4
5
函数分类：
有参数无返回值
有参数有返回值
无参数无返回值
无参数有返回值

5.函数进阶

0x01:全局变量和局部变量

局部变量：

函数内部定义的变量（生效范围只在函数的内部，不同的函数可以定义相同的局部变量互不干扰，局部变量为了临时的保存数据，需要在函数中定义来进行存储

全局变量：

当全局变量和局部变量出现重复定义的时候，程序会优先执行使用函数内部定义的变量

如果在函数的内部想对全局变量进行修改的话，必须使用global关键字进行声明

修改全局变量：

1
2
3
4
5
6
7
8
name = 'yuer'
def changeGlobal():
	global name
	name = 'cookie'
	pass
changeGlobal()
print(name)
0x02:函数参数引用传值

不可变类型

int str 元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 1
print("a的地址：{}".format(id(a)))
def func(x):
    print("x的地址：{}".format(id(x)))
    x = 2
    print("x的地址：{}".format(id(x)))
    pass
func(a)
print("a的地址：{}".format(id(a)))
print(a)

# a的地址：140706376876304
# x的地址：140706376876304
# x的地址：140706376876336
# 1

可变类型

字典 列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
listA = []
def func(parms):
    print(id(parms))
    parms.append([1,2,3,4])
    print(id(parms))
    print('内部的{}'.format(parms))
    pass
print(id(listA))
func(listA)
print('外部的{}'.format(listA))

# 2715138216456
# 2715138216456
# 2715138216456
# 内部的[[1, 2, 3, 4]] 
# 外部的[[1, 2, 3, 4]]  数据同步变化

小结

1.在python中 万物皆对象，在函数调用的时候，实参传递的就是对象的引用

2.更好的把控 在函数内部的处理是否会影响函数外部数据的变化

3.参数传递是通过对象引用来完成

0x03:匿名函数

利用lambda关键字创建匿名函数

1
lambda 参数1,参数2,参数3:执行代码语句

1.没有名字的函数

2.匿名函数冒号后面的表达式有且只有一个（是表达式，不是语句

3.匿名函数自带return

4.用变量接收匿名函数，用变量进行调用

5.但是只能是单个表达式，不是一个代码块，只是为了满足简单函数的场景，仅仅能封装有限的逻辑，复杂逻辑实现不了

eg：

1
2
3
4
5
6
7
8
9
a = lambda x,y:x+y
print(a(1,2))

######

d = lambda a,b,c:a*b*c
print(d(1,2,3))

######

双分支变但分支：

1
2
b if a else c
#如果a成立则返回b 否则返回c

结合：

1
2
3
#直接调用
jg = (lambda x,y:x if x>y else y)(1,4)
print(jg)
0x04:递归函数

如果一个函数在内部不调用其他函数，而是自己本身的话，这个函数就是递归函数

递归函数必须有一个结束条件，否则递归无法结束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 求阶乘

def func(x):
    if x == 1:
        return 1;
    else:
        return x * func(x-1)
    pass
print(func(5))

# 模拟文件查找 实现树形结构的遍历

import os #引入文件操作模块
def findFile(file_path):
    listRs = os.listdir(file_path) #得到该路径下所有的文件夹
    for item in listRs:
        full_path = os.path.join(file_path, item)
        #获取完整的文件路径
        if os.path.isdir(full_path):
        #判断是否是文件夹
        	file_path(full_path)
        else:
            print(item)
            pass
        pass
    else:
        return 
    pass

1.自己调用自己

2.必须有一个明确的结束条件

3.优点：逻辑简单，定义简单

4.缺点：容易导致栈溢出。内存资源紧张，甚至内存泄漏

6.内置函数

0x01:数学运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
abs()  求绝对值函数
返回数字的绝对值

round()
求近似值

pow()
求次方

divmod()
求商和余数

max()
min()
最值

sum()
和

eval()
将字符串当作代码
0x02:类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#数据类型的转换
int()
float()
str()

#ascii码相互转换
ord()
chr() 

bool()

bin()
hex()
oct() 转成八进制

list() 元组转换成列表
tuple()
dict() 创建字典

bytes()

dict()字典操作（主要用于创建字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#语法
# class dict(**kwarg)
# class dict(mapping,**kwarg)
# class dict(iterable,**kwarg)

#参数
# **kwarg  关键字
# mapping 元素的容器
# iterable 可迭代对象

#返回值
#返回一个字典

dic = dict(name='cookie')
print(type(dic))
dic.update({'name':'yuer'})  #更新数据或者增加数据
dic['age'] = 18
print(dic)

bytes()转为字节数组

1
2
3
4
5
6
7
8
9
10
11
12
#语法
# class bytearray([source[,encoding]]])
#参数
# source 为整数，则返回一个长度为source的初始化数组
#        为字符串，则按照指定的encoding将字符串转换成字节序列
#        为可迭代类型，则元素必须为[0,255]中的整数
#        为与buffer接口一致的对象，则次对象也可以被用于初始化bytes
#        如果没有输入任何参数，默认就是初始化数组为0个元素
#返回值
#返回新字节数组

print(bytes('w我like python',encoding='utf-8'))
0x03:序列操作
1
2
3
4
5
6
7
all()
any()
sorted()
reverse()
range()
zip()
enumerate()

all()与的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是返回True，否则返回False元素，除了是0，空，FALSE外都算TRUE
#函数等价于：
def all(iterable):
    for element in iterable:
        if not element:
            return False
     return True

#语法
# all(iterable)
#参数
#iterable 元组或者列表
#tip
#空元组、空列表返回值为True

li = []
tup = ()
print(all(li)) #Trur
print(all(li)) #True
li = [1,2,3,False]
print(all(li)) #False
tup = (1,2,0)
print(all(tup)) #False

any()或的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#用于判断给定的可迭代参数iterable是否全部为False，则返回False，如果有一个True，则返回True
#函数等价于
def any(iterable):
    for element in iterable:
        if element:
            return True
     return False

#例子
li = [1,2,3,0]
print(any(li)) #True
li = [0,False]
print(ant(li)) #False
li = ['',0,false]

sorted()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#对所有可迭代的对象进行排序操作(list str tuple dict)
#和sort区别：
#sort是应用再list上的方法，sorted可以对所有可迭代对象进行排序操作
#list的sort方法返回的是对已经存在的列表进行操作，
  #而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的
#语法：
# sorted(iterable[,cmp[,key[,reverse]]])
#参数：
#cmp 比较函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0
#key 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中去，指定可迭代对象中的以恶搞元素来进行排序
#reverse 排序规则，reverse = True 降序，反之升序
#返回重新排序的列表

li = [1,3,2,5,6,8]
print(sorted(li))  #[1, 2, 3, 5, 6, 8]
print(sorted(li,reverse=True)) #[8, 6, 5, 3, 2, 1]
print(sorted(li,reverse=False)) #[1, 2, 3, 5, 6, 8]
li.sort()
print(li) #[1, 2, 3, 5, 6, 8]

reverse()

1
2
3
4
5
# 用于反向列表中的元素

li = [1,3,5,7]
li.reverse()
print(li)

range()

1
2
3
# 创建一个整数列表，一般用在for循环中

range(start,stop[,step])

zip()

1
2
3
4
5
6
7
8
9
10
11
# 用来打包的
a = zip([1,2,3],['a','b','c','d'])
print(list(a))
# [(1,'a'),(2,'b'),(3,'c')]

s1 = ['a','b','c']
s2 = ['你','我','他']
print(list(zip(s1,s2)))
# [('a', '你'), ('b', '我'), ('c', '他')]

# 不同序列中的数据根据索引一一对应，并组成元组，各个元组又组成一个列表，每个元组元素的个数由最短的序列决定

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def printBookInfo():
    books = [] 
    id = input("请输入图书编号: ").split
    bookName = input("请输入书名:")
    bookPos = input("请输入位置:")
    idList = id.split(' ')
    bookNameList = bookName.split(' ')
    posList = bookPos.split(' ')
    bookInfo = zip(idList, bookNameList, posList)
    for item in bookInfo:
        '''
        遍历图书信息，进行存储
        '''
        dictInfo = {'编号':item[0],'书名':item[1],'位置':item[2]}
        books.append(dictInfo)
        #将字典对象添加到list容器中
        pass
    for i in books:
        print(i)
        pass
    pass
printBookInfo()

enumerate()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中
# enumerate(sequence,[start=0])

li = [1, 2, 3, 4, 5, 6]
 for i in enumerate(li, start=0):
     print(i) #索引加元素的元组类型
 for i, j in enumerate(li):
       print(i, j) #分别输出对应的值
dictA = {}
dictA['name'] = 'cookie'
dictA['sex'] = 'female'
for i in enumerate(dictA):
    print(i)  #索引加键的元组类型
    pass
for i, j in enumerate(dictA):
    #遍历字典
    print(i, j, dictA[j])
    pass
0x04:三元运算
1
result = 值1 if 条件 else 值2
0x05:set集合

set（集合）是python中的一种数据类型，是一个无序且不重复的元素集合

特点：

不支持索引和切片，是一个无序的且不重复的容器，类似于字典，但是只有key没有value

1
2
3
4
5
6
#创建集合方式：

set1 = {'1','1'}

list1 = [1,4,2,5]
se2 = set(list1)

集合操作函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# add()
set1 = set()
set1.add('python')
print(set1)

# clear() 清空
set1 = {'1','2','3'}
set1.clear()
print(set1)

# difference()  差集 set1中存在，set2中不存在
set1 = {'1', '2', '3'}
set2 = {'3', '4', '5'}
set3 = set1.difference(set2)
print(set3)

# intersection() 交集
set1 = {'1', '2', '3'}
set2 = {'3', '4', '5'}
set3 = set1.intersection(set1, set2)
print(set3)

# union()  并集
set1 = {'1', '2', '3'}
set2 = {'3', '4', '5'}
set3 = set1.union(set1, set2)
print(set3)

# pop() 移除数据 从集合中拿数据并删除
# 移除最小的数据并将剩下的数据进行升序排序
set1 = {'1', '2', '3'}
set1.pop()
print(set1)

# discard()
# update() 更新数据

7.面向对象

0x01:介绍
1
2
面向对象编程：将数据和函数绑定，进行封装，这样能够更快速地开发程序，减少重复代码的重写过程（关注设计思维
————适合做大项目

类和对象

对象是类的实例

0x02:定义类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#class Foo(object):
#    属性
#    方法列表
#    pass

class Person(object):
    name = 'yuer'
    age = 18
    def eat(self): #self关键字
        print("吃饭")
        pass
    def run(self):
        print()
        pass
    def sing(self):
        print()
        pass
a = Person() #进行实例化，a为对象
a.eat() #调用方法
0x03:实例方法、属性、静态方法、类方法

实例方法：在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数

属性：在类的内部定义的变量（类属性

实例属性：定义在方法里面使用self引用的属性称之为实例属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Person:
    native_place='' #直接写在类里面的变量为类属性
    
    #实例方法
    def eat():
        print("eat action")
        pass
    
    #静态方法
    @staticmethod
    def method():
        print("静态方法")
        pass
    
    #类方法
    @classmethod
    def cm(cls):
        print("类方法")
        pass
    
    #初始化方法 （构造方法
	def __init__(self):
		self.name = '小明' #实例属性
		pass
    
p = Person()
0x04:魔术方法

python 魔术方法

常用的魔术方法

魔术方法 解释
__new__ 在对象实例化的时候最先调用的方法
__init__ 构造方法
__del__ 析构方法
__call__ 当对象被当作函数调用的时候自动调用此方法
__len__ 当对象被当作len()调用的时候
__repr__ 当对象被当作repr()调用的时候
__str__ 当对象被当作str()调用的时候
__bytes__ 当对象被当作bytes()调用的时候
__hash__ 当对象被当作hash()调用的时候
__bool__ 当对象被当作bool()调用的时候，应该返回true或false
__format__ 当对象被当作format()调用的时候
__getattr__ 当调用一个不存在的属性的时候执行的行为
__getattribute__ 当该类的属性被访问时所执行的行为
__setattr__ 定义当一个属性被设置时的行为
__delattr__ 定义当一个属性被删除时的行为
__dir__ 当对象被当作dir()调用时的行为
__get__ 定义当描述符的值被取得时的行为
__reduce__ 当定义扩展类型时（也就是使用Python的C语言API实现的类型），如果你想pickle它们，你必须告诉Python如何pickle它们。 reduce 被定义之后，当对象被Pickle时就会被调用。它要么返回一个代表全局名称的字符串，Pyhton会查找它并pickle，要么返回一个元组。这个元组包含2到5个元素，其中包括：一个可调用的对象，用于重建对象时调用；一个参数元素，供那个可调用对象使用；被传递给 setstate 的状态（可选）；一个产生被pickle的列表元素的迭代器（可选）；一个产生被pickle的字典元素的迭代器（可选）

简单运用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import _pickle
import base64


class Person:
    name = ''
    age = 0

    def __init__(self):
        self.name = 'ameuu'
        self.age = 18
        print("这是构造方法")

    def __del__(self):
        print("这是析构方法")

    def __call__(self, *args, **kwargs):
        print("对象被当作函数调用")

    def __getattr__(self, item):
        print("调用了一个不存在的属性")


if __name__ == '__main__':
    try:
        student = Person()
        # pop = base64.b64encode(_pickle.dumps(student))
        # print(pop)
        student()
        student.a
    except:
        print("error")

Pickle的dumps和loads:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import base64
import _pickle


class User:
    name: "admin"
    is_admin: 0
    pass


print(_pickle.dumps(User()))
print(base64.b64encode(_pickle.dumps(User())))
usr = _pickle.dumps(User())
print(_pickle.loads(usr))