基本类型的补充
str --> 一次性创建的，不能被修改，强制修改就会在创建一个而之前的也会在
list -->允许重复的集合 修改 记录 链表，下一个元素的位置，上一个元素的位置
tuplt --> 允许重复的集合 修改
dict---> 允许重复的集合 修改
set -->不允许重复的集合，修改 也是不允许重复的列表
set 集合
创建方式有两种 s = set（） s = {，，，，}
s1 = {11,44,55,66,77}
b1 = {11,22,33,44,55,789}
s1.add(88) #添加某一个元素 不能直接打印
print(s1)
结果
{66, 11, 44, 77, 55, 88}
s1.clear() #清空列表 不能清除一个
print(s1)
结果
set()
i = s1.difference (b1) #找s1中存在 b1中不存在的元素，并赋值给i
print(i)
结果‘
{66, 77}
s1.difference_update(b1) #找某一个存在，某一个不存在元素更新自己的
print(s1)
结果
{66, 77}
i = s1.discard(11)
print(s1) #移除指定元素 没有的也不存在保错
结果
{66, 44, 77, 55}
i = s1.remove(11) #移除指定元素，不存在的报错
print(b1)
结果
{33, 11, 44, 789, 22, 55}
i = s1.intersection(b1) #返回两个集合的交集作为一套新的
print(s1)
结果
{66, 11, 44, 77, 55}
i = s1.isdisjoint(b1) #判断有没有交集，有交集就是False，没有交集就是Ture
print(i)
结果
False
i = s1.issubset(b1) #判断是不是子序列
print(i)
结果
False
i = s1.issuperset(b1) #判断是不是父子列
print(i)
结果
False
i = s1.pop() #删除某一个元素 因为是无序的所以是随机 而删除掉的给会赋值给i变量
print(i)
结果
66
i = s1.symmetric_difference(b1)
print(i) #对称交集 就s1中存在 b1中不存在的 b1中存在 s1中不存在的 并进行合集！
结果
{33, 789, 22, 77}
i = s1.union(b1)
print(i) #并集 合并到一个新的集合
结果
{33, 11, 44, 77, 789, 22, 55}
li = [123,321,32113243]
s1.update()
print(li)
执行结果：[123, 321, 32113243]
三目运算 三元运算
name= 值1 if 1 == 1 sles 值2 如果条件成立就把值1赋给变量 如果条件不成立就把值2 赋给变量
q = 'erzi' if 1==1 else 'sunzi'
print(q) q = 'xin' if 1 !=1 else 'pi'
print(q) D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
erzi
pi
Process finished with exit code 0
深浅拷贝。 深浅拷贝有copy模块。
导入模块：import copy
浅拷贝：copy.copy
深拷贝：deepcopy
字面理解：浅拷贝指仅仅拷贝数据集合的第一层数据，深拷贝指拷贝数据集合的所有层。
所以对于只有一层的数据集合来说深浅拷贝的意义是一样的，比如字符串，数字。
import copy 先导入模块
q1 = 123
print(id(q1))
q2 = q1
赋值
print(id(q2))
q3 =copy.copy(q1)
浅拷贝 print(id(q3))
q4 = copy.deepcopy(q1)
深拷贝 print(id(q4))
D:\python3.5\python.exe D:/untitled/q1.py
497237680
497237680
497237680
497237680
Process finished with exit code 0
对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同
赋值 只是创建一个变量，该变量指向原来内存地址，如：
q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = q1
print(id（q2)）
D:\python3.5\python.exe D:/untitled/q1.py
10040584
Process finished with exit code 0
浅拷贝 ，在内存中只额外创建第一层数据 拷贝加赋值 的id地址都一样的
q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = copy.copy(q1)
print(id(q1)，id（q2）)
D:\python3.5\python.exe D:/untitled/q1.py
7503144 15611144
Process finished with exit code 0
深拷贝，全部拷贝，除了最后一层的值
在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）
q1 = {'k1':'v1','k2':'v2','k3':['xin',321]}
q2 = copy.deepcopy(q1)
print(id(q1),id(q2))
D:\python3.5\python.exe D:/untitled/q1.py
11238696 12160016
Process finished with exit code 0
函数：
函数 是面向过程编程
函数编程
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
你可以定义一个由自己想要功能的函数，以下是简单的规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
定义函数
def xin(): # 只输入一次 以后可以直接调用 不需要继续重新输入或者复制粘贴
print('qwertryu')
def kai():
print('ertyuidfghjcvbnm')
# #执行函数
xin() #从上往下执行
kai()
# return #就是返回值 每次执行完结果都要定义一个返回值，不定义自动返回HONE
def xin ():
print('xinxinxin')
return 'ok' 记得要定义返回值
ret = xin()
print(ret)
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
xinxinxin
ok Process finished with exit code 0
def xin(): 定义函数名称
print('qwe')
ret = xin()执行函数
if ret: 如果返回值是真的
prtint('haha')
else: 否则就是假的
print('gun')
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
qwe
gun Process finished with exit code 0
参数 分为 形式参数， 实际参数 ， 动态参数
形参 ，实参 （默认的，按照顺序）
指定 形参传入实参，可以不按照顺序
函数可以有默认参数，（有默认值的参数一定要放在参数的尾部）
动态参数 *，元祖 ，元祖的元素
**，字典
形式参数 和 实际参数
def kai (i): #(i) 形式参数，
if i == "123456789": #如果形式参数等于实际参数的值
return True # 就返回成功 下面的代码就不执行了
else: #否则
return False #就返回失败 继续执行 q1 = kai('123456789') #实际参数就是定义的返回值
q2 = kai('789465132')
if q1: #如果执行的实际参数是就是形式参数
print('yes') #就是成功了
else: #否则
print('no') #否则就是失败了 D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
yes Process finished with exit code 0
执行参数：
def xin(w,x ):
print(w,x)
return'sss'
s = xin(x= 'xx',w= '')
print(s)
执行结果：
33 xx
sss
动态参数
加 * 号就是动态参数
def niu(*a):
print(a,type(a)) #元祖类型
niu(123,456,543,654,432,654,423) D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
(123, 456, 543, 654, 432, 654, 423) <class 'tuple'> Process finished with exit code 0 def niu (**a): # 字典类型
print(a,type(a))
niu(k1=123,k2=456)
D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
{'k1': 123, 'k2': 456} <class 'dict'> Process finished with exit code 0 def xin (*a,**aa): 接受和各种类型的参数
print(a,type(a))
print(aa,type(aa))
xin(11,22,k1=23,k2 =123) D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
(11, 22) <class 'tuple'>
{'k2': 123, 'k1': 23} <class 'dict'> Process finished with exit code 0
一般把一个 *写成 args
** kwargs
也可以写成 *a。**aa。
def q1(* args):
print(args,type(args))
li = [1,2,3,4,5]
q1(li) 元祖里的一个元素
q1(*li) 把每个元素都加入到 元祖里 D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
([1, 2, 3, 4, 5],) <class 'tuple'>
(1, 2, 3, 4, 5) <class 'tuple'> Process finished with exit code 0
全局变量 局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
PERSON = 'alex'
###全局变量 全局变量都大写不能被修改 如果要修改的话必须加global
def x1 ():
a = 12
#局部变量 ，都为小写只能在自己的范围内
print(PERSON)
print(a)
x1() D:\python3.5\python.exe D:/untitled/.idea/sanyuan.py
alex
12 Process finished with exit code 0