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