python自学第三周总结

首字母大写：列表.title()

>>> name = ['kobe','allen','ray','obito']
							  
>>> name
							  
['kobe', 'allen', 'ray', 'obito']
>>> name[1].title()
							  
'Allen'

全部升级大写：
`>>> name[2].upper()

‘RAY’`
全部小写：

>>> name[2].lower()
							  
'ray'

list：也可以生成一个列表，并且可以进行索引。

>>> list1 = ['james','haden','blue']
							  
>>> list1
							  
['james', 'haden', 'blue']
>>> list1[1:2]
							  
['haden']
>>> list1[:2]
							  
['james', 'haden']

max：返回最大值

>>> max(1,5,59,45,10)
							  
59

min：返回最小值（同上）
sum：返回和

>>> sum([1,1,2])
							  
4

sorted：排序，从大到小

>>> num = [1,59,54,62,12,6]							  
>>> num						  
[1, 59, 54, 62, 12, 6]
>>> sorted(num)						  
[1, 6, 12, 54, 59, 62]

reversed：返回到地址：

>>> reversed(num)
							  
<list_reverseiterator object at 0x000002AE116B5160>

list（reversed(列表))：返回到列表的值

>>> list(reversed(num))
							  
[6, 12, 62, 54, 59, 1]

**enumerate()**枚举

>>> enumerate(num)					  
<enumerate object at 0x000002AE116A3E10>
>>> list(enumerate(num))					  
[(0, 1), (1, 59), (2, 54), (3, 62), (4, 12), (5, 6)]

zip：返回两个序列组成的参数，类似于映射

>>> a = ['kobe','allen','james','yao']
							  
>>> b = [24,3,23,11]
							  
>>> zip(a,b)
							  
<zip object at 0x000002AE113D7948>
>>> list(zip(a,b))
							  
[('kobe', 24), ('allen', 3), ('james', 23), ('yao', 11)]

定义函数：
1.def 函数名(参数名)：
2.函数内容以冒号为起始，并且缩进
3.return 表示结束函数，并且返回一个值

形参与实参
形参：原本定义的，一开始就存在的
实参：后面传递进来的

lambda函数：
lambda 参数，参数：表达式

>>> s = lambda x,y:x+y
							  
>>> print('x+y的值为： ',s(15,20))
							  
x+y的值为：  35

不需要在定义函数，直接使用函数表达式。
全局变量和局部变量：定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
local variable 函数内的参数
global variable 函数外的参数

两个牛x的bif
1、filter() 过滤器，过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

>>> list(filter(lambda x : x % 2,range(10)))
	 
[1, 3, 5, 7, 9]
>>> 

2、map()函数

>>> list(map(lambda x : x*2,range(10)))
	 
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

将序列的每一个元素作为函数的参数进行运算，直到全部运算结束。