2. python入门杂记

元祖

创建一个元祖(逗号是关键)

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})