标签：判断 函数调用 otto and 引用 项目 等于 插入 规则
本质：无序和无重复元素的集合
创建：
创建set需要一个list或者tuple或者dict作为输入集合
重复元素在set中会自动被过滤
s1 = set([1,2,3,4,5,3,4,5,6]) 值为 {1,2,3,4,5,6}
s2 = set((1,2,3,4,5,1,2,3)) 值为 {1,2,3,4,5}
添加
s4 = set([1,2,3,4,5])
s4.add(6)
s4.add(4) 可以添加重复的 但是没有效果
s4.add((7,8,9)) set的元素不能是列表和字典，因为列表和字典是可变的
插入元组 是将元组当成一个元素来看的
插入整个list、tuple、字符串,打碎插入
s5 = set([1,2,3,4,5])
s5.update([6,7,8]) 值为{1，2，3，4，5，6，7，8}
这个插入元素，不会将元组当成一个元素来看
删除
s6 = set([1,2,3,4,5])
s6.remove(3)
遍历
s7 = set([1,2,3,4,5])
for i in s7
print(i)
set没有索引的
交集
s8 = set([1,2,3])
s9 = set([2,3,4])
a1 = s8 & s9
并集
a2 = s8 | s9
类型转换
list -> set
L1 = [1,2,3,4,5,3,4,5]
s1 = set(L1)
tuple ->set
t2 = (1,2,3,4,3,2)
s2 = set(t2)
set - >list
s3 = {1,2,3,4}
l3 = list(s3)
set->tuple
s4 = {2,3,4,5}
t4 = tuple(s4)
迭代器
可迭代对象
导入 from collections import Iteralbe
可以直接作用于for循环的对象统称为可迭代对象(Iteralbe)
可以用isinstance()去判断一个对象是否是可迭代对象
可以直接作用于for的数据类型一般分两种
集合数据类型，如list、tuple、dict、set、string
是generator，包括生成器和带yield的generator function
print(isinstance([],Iterable)) 返回True
迭代器
导入 from collections import Iterator
不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后会抛出一个StopIteration错误表示无法继续返回下一个值
可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)
可以使用 isinstance()函数判断一个对象是否是Iterator对象
l = (x for x in range(5))
print(next(1)) 0
print(next(1)) 1
print(next(1)) 2
print(next(1)) 3
print(next(1)) 4
.
.
转成Iterator对象
a = iter([1,2,3,4,5])
print(next(a)) 1
print(next(a)) 2
iter(object,sentinel)
object必须是集合对象，且支持迭代协议
sentinel
如果传递了第二个参数，则object必须是一个可调用的对象（如，函数）。此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用object。
如果next的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值。
函数
函数概述
认识函数：在一个完整的项目中，某些功能会反复的使用。那么 会将功能封装成函数，当我们要使用功能时候，直接调用函数即可
本质：函数就是对功能的封装
优点：
简化代码结构，增加了代码的复用度(重复使用的程度)
如果想修改某些功能或者调式某个BUG，只需要修改对应的函数即可
定义函数：
格式:
def 函数名(参数列表):
语句
return 表达式
def:函数代码块以def关键字开始
函数名:遵循标识符规则
():是参数列表的开始和结束
参数列表(参数1,参数2，.......参数n)：
任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息
冒号: 函数内容(封装的功能)以冒号开始，并且缩进
语句: 函数封装的功能
return: 一般用于结束函数的，并返回信息给函数的调用者
表达式: 即为要返回给函数的调用者的信息
注意：最后的return 表达式，可以不写，相当于return None
函数的调用
格式： 函数名(参数列表)
函数名: 是要使用的功能的函数名字
参数列表: 函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略
函数调用的本质: 实参给形参赋值的过程
函数的参数
实参(实际参数): 调用函数时给函数传递的数据，本质是值
形参(形式参数): 定义函数时小括号中的变量，本质是变量
参数必须按顺序传递，个数目前要对应
函数的返回值
通过return 返回值给调用者
传递参数
值传递
传递的不可变类型
string、tuple、number是不可变的
引用传递
传递的可变类型
list、dict、set是可变的
关键字参数
概念：允许函数调用时参数的顺序与定义时不一致
def myprint(str,age)
print(str,age)
使用关键字参数 myprint(age= 18,str = "xiaoxin")
默认参数
概念：调用函数时，如果没有传递参数，则使用默认参数
def myprint(str=“xiaoxin”,age=18)
print(str ,age) #值为 xiaoxin 18
myprint()
以后要用默认参数，最好将默认参数放到最后
不定长参数
概念：能处理比定义时更多的参数
加了星号(*)的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组
def func(name,*arr)
print(name)
for x in arr:
print(x)
func("good","nice","happy","handsome")
.
**代表键-值对参数字典，和 *所代表的意义类似
def func2(**kwargs)
print(kwargs)
func2(x = 1,y =2,z=3) 实参必须为关键字参数
匿名函数
概念：不使用def这样的语句定义函数，使用lambda来创建匿名函数
特定：
lambda：只是一个表达式。函数体比def简单
lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑
lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
虽然lambda是一个表达式且看起来只能写一行，与C和C++内联函数不同
格式 :
lambda 参数1, 参数2, .......，参数n: expression
sum = lambda num1,num2: num1+num2
tuple
本质：是一种有序集合
特定：
与列表非常相似
一旦初始化就不能修改
使用小括号
创建tuple
格式： 元组名 = （元组元素1，元组元素2，.......,元组元素n）
创建空的元组
tuplel = ()
print(tuplel)
创建带有元素的元组
tuple2 = (1,2,3,"good",True)
print(tuple2)
定义只有一个元素的元组
tuple3 = (1,)
print(tuple3)
元组元素的访问
格式： 元组名[下标] 下标从0开始
tuple4 = (1,2,3,4,5)
tuple4[0]
tuple4[-1] 获取最后一个元素
修改元组
tuple5 = (1,2,3,4,[5,6,7])
tuple5[0] =100 #会报错， 元组不能变
tuple5[-1] [0] = 500 #不会报错 5变成了500
元组不能变，说的是元组里面的元素不能变，但是元组里面存列表等，列表里面的元素是可以改变的
删除元组
tuple6 =(1,2,3)
del tuple6
元组的操作
t7 = (1,2,3)
t8 = (4,5,6)
t9 = t7+t8 生成一个新的元组给t9 ，但t7和t8本身不改变
元组重复
t10 = (1,2,3)
print(t10*3)
判断元素是否在元组中
t11 = (1,2,3)
print(1 in t11)
元组的截取
格式：
元组名[开始下标:结束下标]
从开始下标开始截取，截取到结束下标之前
t12 = （1,2,3,4,5,6,7,8,9）
t12[3:7]
二维元组：元素为一维元组的元组
t13 = ((1,2,3),(4,5,6),(7,8,9))
t13[1] [1] 值为5
元组的方法
len(t13) 返回元组中元素的个数
max(t13) 返回元组中的最大值
min(t13) 返回元组中的最小值
将列表转成元组
list = [1,2,3]
t15 = tuple(list)
元组的遍历
for i in (1,2,3,4,5):
字典
概述:
使用键-值(key-value) 存储，具有极快的查找速度
注意： 字典是无序的
key的特性
字典中的key必须唯一
key必须是不可变的对象
字符串、整数等都是不可变的，可以作为key
list是可变的，不能作为key
字典的创建
dict1 = {"tom":60,"lilei":70}
元素的访问
获取: 字典名[key]
print(dict1["lilei"]) 值为70
print(dict1.get("sunck")) 没有找到 返回None
元素的添加
dict1["hanmeimei"] = 99
dict1["lilei"] = 80
因为一个key对应一个value，所以，多次对一个key的value赋值，其实就是修改值
元素的删除
dict1.pop("tom") tom就被删除了
遍历
for key in dict1:
print(key, dict1[key])
for value in dict1.values(): [60,80,90] 将字典的值取出来
print(value)
for k,v in dict1.items():
print(k,v) 能把字典的元素全部打出来 key和value
和list比较
查找和插入的速度极快，不会随着key-value的增加而变慢
需要占用大量的内存，内存浪费多
list
查找和插入的速度随着数据量的增多而减慢
本质：无序和无重复元素的集合
创建：
创建set需要一个list或者tuple或者dict作为输入集合
重复元素在set中会自动被过滤
s1 = set([1,2,3,4,5,3,4,5,6]) 值为 {1,2,3,4,5,6}
s2 = set((1,2,3,4,5,1,2,3)) 值为 {1,2,3,4,5}
添加
s4 = set([1,2,3,4,5])
s4.add(6)
s4.add(4) 可以添加重复的 但是没有效果
s4.add((7,8,9)) set的元素不能是列表和字典，因为列表和字典是可变的
插入元组 是将元组当成一个元素来看的
插入整个list、tuple、字符串,打碎插入
s5 = set([1,2,3,4,5])
s5.update([6,7,8]) 值为{1，2，3，4，5，6，7，8}
这个插入元素，不会将元组当成一个元素来看
删除
s6 = set([1,2,3,4,5])
s6.remove(3)
遍历
s7 = set([1,2,3,4,5])
for i in s7
print(i)
set没有索引的
交集
s8 = set([1,2,3])
s9 = set([2,3,4])
a1 = s8 & s9
并集
a2 = s8 | s9
类型转换
list -> set
L1 = [1,2,3,4,5,3,4,5]
s1 = set(L1)
tuple ->set
t2 = (1,2,3,4,3,2)
s2 = set(t2)
set - >list
s3 = {1,2,3,4}
l3 = list(s3)
set->tuple
s4 = {2,3,4,5}
t4 = tuple(s4)
迭代器
可迭代对象
导入 from collections import Iteralbe
可以直接作用于for循环的对象统称为可迭代对象(Iteralbe)
可以用isinstance()去判断一个对象是否是可迭代对象
可以直接作用于for的数据类型一般分两种
集合数据类型，如list、tuple、dict、set、string
是generator，包括生成器和带yield的generator function
print(isinstance([],Iterable)) 返回True
迭代器
导入 from collections import Iterator
不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后会抛出一个StopIteration错误表示无法继续返回下一个值
可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)
可以使用 isinstance()函数判断一个对象是否是Iterator对象
l = (x for x in range(5))
print(next(1)) 0
print(next(1)) 1
print(next(1)) 2
print(next(1)) 3
print(next(1)) 4
.
.
转成Iterator对象
a = iter([1,2,3,4,5])
print(next(a)) 1
print(next(a)) 2
iter(object,sentinel)
object必须是集合对象，且支持迭代协议
sentinel
如果传递了第二个参数，则object必须是一个可调用的对象（如，函数）。此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用object。
如果next的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值。
函数
函数概述
认识函数：在一个完整的项目中，某些功能会反复的使用。那么 会将功能封装成函数，当我们要使用功能时候，直接调用函数即可
本质：函数就是对功能的封装
优点：
简化代码结构，增加了代码的复用度(重复使用的程度)
如果想修改某些功能或者调式某个BUG，只需要修改对应的函数即可
定义函数：
格式:
def 函数名(参数列表):
语句
return 表达式
def:函数代码块以def关键字开始
函数名:遵循标识符规则
():是参数列表的开始和结束
参数列表(参数1,参数2，.......参数n)：
任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息
冒号: 函数内容(封装的功能)以冒号开始，并且缩进
语句: 函数封装的功能
return: 一般用于结束函数的，并返回信息给函数的调用者
表达式: 即为要返回给函数的调用者的信息
注意：最后的return 表达式，可以不写，相当于return None
函数的调用
格式： 函数名(参数列表)
函数名: 是要使用的功能的函数名字
参数列表: 函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略
函数调用的本质: 实参给形参赋值的过程
函数的参数
实参(实际参数): 调用函数时给函数传递的数据，本质是值
形参(形式参数): 定义函数时小括号中的变量，本质是变量
参数必须按顺序传递，个数目前要对应
函数的返回值
通过return 返回值给调用者
传递参数
值传递
传递的不可变类型
string、tuple、number是不可变的
引用传递
传递的可变类型
list、dict、set是可变的
关键字参数
概念：允许函数调用时参数的顺序与定义时不一致
def myprint(str,age)
print(str,age)
使用关键字参数 myprint(age= 18,str = "xiaoxin")
默认参数
概念：调用函数时，如果没有传递参数，则使用默认参数
def myprint(str=“xiaoxin”,age=18)
print(str ,age) #值为 xiaoxin 18
myprint()
以后要用默认参数，最好将默认参数放到最后
不定长参数
概念：能处理比定义时更多的参数
加了星号(*)的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组
def func(name,*arr)
print(name)
for x in arr:
print(x)
func("good","nice","happy","handsome")
.
**代表键-值对参数字典，和 *所代表的意义类似
def func2(**kwargs)
print(kwargs)
func2(x = 1,y =2,z=3) 实参必须为关键字参数
匿名函数
概念：不使用def这样的语句定义函数，使用lambda来创建匿名函数
特定：
lambda：只是一个表达式。函数体比def简单
lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑
lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数
虽然lambda是一个表达式且看起来只能写一行，与C和C++内联函数不同
格式 :
lambda 参数1, 参数2, .......，参数n: expression
sum = lambda num1,num2: num1+num2
print(sum(1,2)) 结果为3
标签：判断 函数调用 otto and 引用 项目 等于 插入 规则
原文地址：https://www.cnblogs.com/fengzi759/p/12001157.html
