基本数据类型特性分组
- 可变不可变
1.可变：列表、字典
2.不可变：字符串、数字、元祖 - 访问顺序
1 直接访问：数字
2.顺序访问：字符串、列表、元祖
3.映射：字典 - 存放元素个数
容器类型：字典、元祖、列表
原子类型：数字、字符串
集合
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
1.不同元素组成
2.无序的
3.集合中的元素必须是不可变类型
特性：
1.集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
创建集合
#直接大括号写
s = {1, 2, 3, 4, 4, 5, 5, 5, 5}
print(s)
set一个可迭代对象（可for循环对象）
l = set('hello')
print(l)
集合的方法
s = {1, 2, 3, 4, 4, 5, 5, 5, 5}
print(s)
#增加元素
s.add(6)
print(s)
#清空
s.clear()
print(s)
#复制
s1=s.copy()
print(s1)
l={1,2,3,4,5,6}
---------------------------------------------------------------------------------------------------------------------------
#随机删除
l.pop()
#指定删除
l.remove(6)
l.remove('hello')#删除不存在的元素会报错
l.discard('hello')#删除元素不存在不会报错
print(l)
----------------------------------------------------------------------------------------------------------------------------
demo_1=['悟空','八戒','沙悟净','唐僧']
demo_2=['悟空','牛魔','大鹏']
#列表转换为集合
d_1=set(demo_1)
d_2=set(demo_2)
print(d_1,d_2)
#求两个集合的交集
jiaoji=d_1.intersection(d_2)
print(jiaoji)
#第二种写法
print(d_2&d_2)
#求并集
print(d_2.union(d_1))
print(d_1|d_2)
#求差集
#d_1中有d_2中没有的值
print('差集',d_1-d_2)
print(d_1.difference(d_2))
#d_2中有d_2中没有的值
print('差集',d_2-d_1)
print(d_2.difference(d_1))
# 对称差集：方法返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素。
print(d_1.symmetric_difference(d_2))
#判断两集合是否有交集，有交集为False，没有交集为True
print(d_2.isdisjoint(d_1))
#判断是否为摸个集合的子集，是为True，否为False
s1={1,2}
s2={1,2,3}
print(d_1.issubset(d_2))
print(s1.issubset(s2))
#判断是否为摸个集合的父集，是为True，否为False
print(s2.issuperset(s1))
print(d_2.issuperset(d_1))
#更新多个值,可传集合，元祖列表，所有可迭代对象
s2.update(s1)
print(s2,s1)
- 补充
set方法定义的是可变集合
frozenset 定义的为不可变集合
#frozenset定义的集合没有pop，add方法不可更改
q1=[1,2,2,23,3]
Q1=set(q1)
print(Q1)
Q2=frozenset(q1)
print(Q2)
-----------------------------------------------
{1, 2, 3, 23}
frozenset({1, 2, 3, 23})
函数
python中函数定义：函数是逻辑结构化和过程化的一种编程方法
编程语言中的函数是通过一个函数名封装好一串用来完成某一特定功能的逻辑
python中函数定义方法：
def test(x):
"The function definitions"
x+=1
return x
def:定义函数的关键字
test：函数名
（）：内可定义形参
"":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值
调用运行：可以带参数也可以不带
函数名()
过程
过程定义：过程就是简单特殊没有返回值的函数
def test01():
msg = 'hello The little green frog'
print(msg)
def test02():
msg = 'hello Tom'
print(msg)
return msg
t1 = test01()
t2 = test02()
print('from test01 return is [%s]' % t1)
print('from test02 return is [%s]' % t2)
---------------------------------------------------------------------------------------
运行结果：
hello The little green frog
hello Tom
from test01 return is [None]
from test02 return is [hello Tom]
总结：当一个函数/过程没有使用return显示的定义返回值时，python解释器会隐式的返回None，
所以在python中即便是过程也可以算作函数。
def test01():
pass
def test02():
return 0
def test03():
return 0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'}
t1 = test01()
t2 = test02()
t3 = test03()
print('from test01 return is [%s]: ' % type(t1),t1 )
print('from test02 return is [%s]: ' % type(t2),t2)
print ('from test03 return is [%s]: ' % type(t3),t3)
--------------------------------------------------------------------------------------------
运行结果：
from test01 return is [<class 'NoneType'>]: None
from test02 return is [<class 'int'>]: 0
from test03 return is [<class 'tuple'>]: (0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'})
总结：
返回值个数=0:返回None
返回值个数=1:返回object
返回值个数>1:返回tuple
函数参数
1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
image.png
3.位置参数和关键字
- 1标准调用：实参与形参位置一一对，应缺一不行，多一也不行；关键字调用：位置无需固定，应缺一不行，多一也不行
- 2 位置参数和关键字参数混用时候，位置参数必须在关键字参数左边
4.默认参数 - 默认参数不传取默认值，传新的值就赋值新的值
def test (x,type ='plsql'):
print(x)
print(type)
test(100)
-----------------------------------------------------------
运行结果：
100
plsql
test(101,mysql)
-----------------------------------------------------------
运行结果：
101
mysql
5.参数组
列表
def test (x ,args):
(1,2,2,2,2,3,3,34,4)
- 传参如果按照位置参数传多个参数，第一个匹配第一个参数，其他全部传入args，形成一个元祖
如果，第二个参数是列表或者字典，把第二个参数整体做为一个字符串传给args如下面例子
**字典 - 一起用的固定写法 (x ,args,*kwargs)
def test (x ,*args):
print(x)
print(args)
test(1,2,2,2,2,3,3,34,4)
-------------------------------------------------------------------------
运行结果：
1
(2, 2, 2, 2, 3, 3, 34, 4)
test(1,{'name':'Tom',"sex":1})
----------------------------------------------------------------------
运行结果
1
({'name': 'Tom', 'sex': 1},)
def test (x,**kwargs):
print(x)
print(kwargs)
test(1,z=1,y=2)
---------------------------------------------------------------------
运行结果
1
{'z': 1, 'y': 2}
def test (x ,*args,**kwargs):
print(x)
print(args)
print(kwargs)
test(1,2323232,232,3,23,232,y=12211,c=4322 )
print('***************************************')
test(1,*[2,3.2,32,2,3],**{'q':1,'w':21})
----------------------------------------------------------------------------
1
(2323232, 232, 3, 23, 232)
{'y': 12211, 'c': 4322}
***************************************
1
(2, 3.2, 32, 2, 3)
{'q': 1, 'w': 21}
局部变量和全局变量
name = '姚明'
def change_name():
name = '詹姆斯'
print('change_name:', name)
change_name()
def change_name2():
print('change_name:',name)
change_name2()
NAME = 'Tom'
def change_name():
# NAME='Jack'
global NAME#已声明NAME就是全局变量那个变量
print('change_name: ', NAME)
NAME='alex' #修改全局变量
print('change name:',NAME)
def change_name2():
# NAME='Jack'
global NAME # 已声明NAME就是全局变量那个变量
print('change_name: ', NAME)
change_name2()
change_name()
__________________________________________
运行结果;
change_name: Tom
change_name: Tom
change name: alex
NAME = 'Tom'
def change_name():
# NAME='Jack'
global NAME#已声明NAME就是全局变量那个变量
print('change_name: ', NAME)
NAME='alex' #修改全局变量
print('change name:',NAME)
def change_name2():
# NAME='Jack'
global NAME # 已声明NAME就是全局变量那个变量
print('change_name: ', NAME)
change_name()
change_name2()
------------------------------------------------------------------
运行结果
change_name: Tom
change name: alex
change_name: alex
注意：
Python是从上到下运行，如果一个函数没有被调用，不执行函数内部的代码，故上面代码运行结果不一致
- 如果函数内部没有global关键字，优先读取局部变量，没读到只能读取全局变量，无法对全局变量重新赋值
- 如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值
函数里面可以嵌套函数
NAME = 'yaomong' #1
def lijunyang():
name = '李俊杨'#3
print(name) #4
def liqiang():
name = '李强' #6
print(name) #7
def lining():
name = '李宁' #9
print('李宁') #10
lining() #8
liqiang() #5
lijunyang() #2
------------------------------
执行结果：
李俊杨
李强
李宁
前向引用之'函数即变量'
python从上到下执行，函数在引用之前必须声明，否则执行到未声明的函数，不再内存中会报错
def show():
print('show方法')
notshow()
def notshow():
print('notshow方法')
show()
------------------------------------------
运行结果
show方法
notshow方法
def show():
print('show方法')
notshow()
show()
def notshow():
print('notshow方法')
---------------------------------------------------
运行结果：
NameError: name 'notshow' is not defined
递归调用
递归特性:
- 必须有一个明确的结束条件否则是死循环会内存溢出
- 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
#死循环会内存溢出
def foo(n):
print(n)
foo(n)
foo(10)
--------------------------------------
运行结果
RecursionError: maximum recursion depth exceeded while calling a Python object
