元祖
- 创建一个元祖(逗号是关键)
touple1 = (1,2,3,4,5) //不可修改
可以使用类似列表的访问方法, 分片
touple1[1] touple1[:3]
touple2 = 2,3,4
touple3 =() 一个空的元祖
tmp = 1, =====> 元祖类型
tmp = (1) ======>int类型
tmp = (1,) ====>元祖类型
8*(8,) =====> (8, 8, 8, 8, 8, 8, 8, 8)
- 更新和删除一个元祖
#由于元祖不能修改,所以更新是重新拼凑一个元素付给这个变量名
temp=('小甲鱼', '黑夜', '彩虹')
temp=temp[:1]+('白天',)+[1:] # 不要忘记白天后面的逗号,这是元祖之间的操作
del temp # 删除元祖
字符串
- 格式化字符串
"{0} love {1}.{2}".format("I", "FishC", "com") ====>'I love FishC.com'
"{a} love {b}.{c}".format(a="I", b="FishC", c="com") ====>'I love FishC.com'
"{{0}}".format("不打印") =====> '{0}'
'{0:.1f}{1}'.format(27.658, 'GB') ======> '27.7GB' #会四舍五入
'%c' % 97 =====> 'a'
'%c %c %c' % (97,98,99) ======> 'a b c'
序列
列表, 元祖和字符串的共同点
都可以通过索引的到每一个元素 默认索引值总是从0开始 可以通过分片的方法得到一个范围内的元素的集合 有很多共同的操作符(重复操作符, 拼接操作符, 成员关系操作符)
内置函数
len() #长度
list() #迭代转化成列表
####仅应用于同一类型之间
max() #最大值
min() #最小值
sum() #求和
sorted() #排序
reversed() #逆置 返回迭代器对象
enumerate() #枚举 下标与值组合的迭代器对象
number=[-98,0,1,13,45,76,3]
list(enumerate(number)) ====》
[(0, -98), (1, 0), (2, 1), (3, 13), (4, 45), (5, 76), (6, 3)]
a = [1,2,3,4,5,6,7,8] b=[4,5,6,7,8]
zip(a,b)
list(zip(a,b))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
函数
- 创建函数
#注意缩进
def MyFirstFunction():
print('this my first func!')
print('i am very happy')
MyFirstFunction() ====> 调用
- 函数文档
>> def MyFirstFunction(name):
'函数定义过程中的name叫做形参'
#因为Ta只是一个形式,便是占据一个参数的位置
print('传递进来的'+name+'叫做实参, 因为Ta是具体的参数值!')
>> MyFirstFunction.__doc__ #默认属性
'函数定义过程中的name叫做形参'
>> help(MyFirstFunction)
Help on function MyFirstFunction in module __main__:
MyFirstFunction(name)
函数定义过程中的name叫做形参
- 关键字参数
使用参数名指定参数,
>>> def SaySome(name, words):
print(name+'->'+words)
>>> SaySome(words='编程改变世界', name='Albin')
Albin->编程改变世界
- 默认参数
>>> def SaySome(name='Albin', words='编程改变世界'):
print(name+'->'+words)
>>> SaySome()
Albin->编程改变世界
- 收集参数
不确定参数的长度
>>> def test(*params):
print('参数的长度是:', len(params));
print('第二个参数是: ', params[1]);
>>> test(1, 'Albin', 3.14, 5, 6)
参数的长度是: 5
第二个参数是: Albin
- 返回值
>>> def hello():
print('Hello World')
>>> temp = hello()
Hello World
>>> print(temp)
None ## 默认的返回值是None
#################
>>> def back():
return [1, '小甲鱼', 3.145]
>>> back()
[1, '小甲鱼', 3.145] # 返回一个列表 可以看作返回多个值
###返回多个值,用逗号隔开,被看做一个元祖,因为创建元祖的标志就是逗号
>>> def back():
return 1, '小甲鱼', 3.145
>>> back()
(1, '小甲鱼', 3.145)
函数内如何修改全局变量
局部变量屏蔽全局变量 在py中,对于上一级作用于的变量,在本级作用于相当于是只读的,不能够对其赋值,如果直接给`x=1`,这样会触发py的屏蔽机制,不会赋值给上一级作用于中的变量,而是重新创建一个同名变量 如果`x+=x`,这样引用上一级变量,会出语法错误,以为屏蔽机制,所以x并没有定义,直接当作右值是不合法的
#global关键字的使用
>>>count=5
>>> def MyFun():
global count
count = 10
>>> MyFun()
>>> print(count)
10
- 内嵌函数和闭包
内嵌函数,因为py支持函数内部仍可以调用函数
>>> def fun1():
print('func()正在被调用')
def func2():
print('func2()正在被调用')
func2()
>>> fun1()
func()正在被调用
func2()正在被调用
>>> func2() #====>因为在全局里面没有定义func2() 所以会报错
闭包:
如果在一个内部函数里,对外部作用域(但不是全局变量)进行引用,那么内部函数就会被认为是闭包
>>> def FunX(x):
def FunY(y): #===》FunY就是一个闭包
return x*y
return FunY
>>> i = FunX(8)
>>> type(i)
<class 'function'>
>>> i(5)
40
>>> FunX(8)(5) #也可以直接调
40
##在2.7以前,在闭包中为了能过引用上一级作用于的变量,可以把变量放到列表中去
>>> def Fun1():
x = [5]
def Fun2():
x[0]*=x[0]
return x[0]
return Fun2()
>>> Fun1()
25
#######nonlocal关键字 (仅用于闭包)
>>> def Fun1():
x = 5
def Fun2():
nonlocal x ## 声明x不是局部变量
x*=x
return x
return Fun2()
>>> Fun1()
25
Lambda 匿名函数
>>> lambda x : 2*x+2
<function <lambda> at 0x03DDA390>
>>> func=lambda x:2*x+2
>>> func(2)
6
##多个参数
>>> g = lambda x, y:x+y
>>> g(2,3)
5
- 活用BTF
#filter(function or None, iterable)
#第一个参数可以是个函数,也可以是个None
#当是函数的时候,会把迭代器里面的值传入函数,把返回值为真的组成一个对象, 可以使用list()弄成一个列表
#如果是None , 就直接判断迭代器里的值,返回真的组成一个对象
>>> list(filter(None, [1, 0, False, True]))
[1, True]
>>> temp = range(10)
>>> def odd(x):
return x%2
>>> show=filter(odd, temp)
>>> list(show)
[1, 3, 5, 7, 9]
###使用lambda表达式改写
>>> show = filter(lambda x:x%2, temp)
>>> list(show)
[1, 3, 5, 7, 9]
###### MAP的是使用
>>> list(map(lambda x: x*2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
- 递归
#阶乘
>>> def fact(x):
if x == 1:
return 1
return fact(x-1)*x
>>> fact(5)
120
- 递归解汉诺塔
def hanoi(n, x, y, z):
if n == 1:
print(x , '-->', z)
else:
hanoi(n-1, x, z, y) #将前n-1个盘子从x移动到y上
print(x, '-->', z) #将最底下的最后一个盘子从x移动到z上
hanoi(n-1, y, x, z)# 将y上的n-1个盘子移动到z上
n = int(input('请输入汉诺塔的层数:'))
hanoi(n, 'X', 'Y', 'Z')
字典
- 字典不是序列类型,是映射类型
>>> brand = ['李宁', '耐克', '阿迪达斯']
>>> slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing']
>>> print('李宁的slogan是:', slogan[brand.index('李宁')])
李宁的slogan是: 一切皆有可能
>>> dict1 = {'李宁':'一切皆有可能', '耐克':'Just do it', '阿迪达斯':'Impossible is nothing'}
>>> print('李宁的slogan是:', dict1['李宁'])
李宁的slogan是: 一切皆有可能
- 创建
>>> dict3 = dict((('F', 70),('i', 105) ))
>>> dict3
{'F': 70, 'i': 105}
>>> dict4 = dict(a = 1, b = 2)
>>> dict4
{'b': 2, 'a': 1}
>>> dict1 = {}
>>> dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
>>> dict1.fromkeys((1,2,3),'Number')
{1: 'Number', 2: 'Number', 3: 'Number'}
>>> dict1.fromkeys((1,2,3), ('one', 'two', 'three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}
- 访问
>>> dict1 = dict1.fromkeys(range(32), '赞')
>>> dict1
{0: '赞', 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: '赞'}
>>> for eachKey in dict1.keys():
print(eachKey)
>>> for eachValue in dict1.values():
print(eachValue)
>>> for eachItem in dict1.items():
print(eachItem)
##如果试图访问字典中没有的
print(dict1[32]) ====> 会报错
# 这是要使用get
dict1.get(32) ====> 会返回一个None
dict1.get(32, '木有') ===> 会返回木有
>>>31 in dict1
True
>>>32 in dict1
False
- 清空
#直接把内存清空
dict1.clear() ====>清空 ,但如果原来的内存被其他标签引用了,也会清空
dict1 = {} # 只是把另一个空的字典贴上dict1的标签,但如果原来的内存被其他标签引用了,不会清空
dict1.pop(2)
dict1.popitem()
- 添加
>>> a = {1:'one', 2:'two'}
>>> a
{1: 'one', 2: 'two'}
>>> a.setdefault('百度')
>>> a
{1: 'one', 2: 'two', '百度': None}
>>> a.setdefault(3, 'three')
'three'
>>> a
{1: 'one', 2: 'two', 3: 'three', '百度': None}
>>> a.setdefault(1)
>>> a
{1: None}
>>> b = {}
>>> b.setdefault(1, 'one')
'one'
>>> a.update(b)
>>> a
{1: 'one'}
集合
唯一, 无须
>>> set1 = set([1,2,3,4,5,5])
>>> set1
{1, 2, 3, 4, 5}
>>>
forzenset
不可变集合
>>> num3 = frozenset([1,2,3,4,5])
>>> num3
frozenset({1, 2, 3, 4, 5})