python知识点总结
变量类型
变量存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。
变量赋值
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。例如：
python逻辑运算符
1.成员
and or not
优先级：() > not > and > or
2.and
逻辑运算符and，a andb，如果a和b都为True，则返回True，如果其中一个为False，返回False，简言之：一假则假，全真则真
3.or
逻辑运算符or，a or b， 如果a和b有一个为True，则返回True，如果全为False，返回False，简言之：一真则真，全假则假
4.not
逻辑运算符not，是结果的相反逻辑，比如 not 4>5为True
python 中else在while循环中的用法
else 可以在while和for循环中运用，else和while或for搭配使用，不再是条件判断的含义。而是当while条件不成立时，直接跳出while循环，执行else输出如：
count = 0
while count > 12:
if True:
print('Yes')
break
count += 1
else:
print('No')
# 输出
Noa = 0
while a < 6:
print('loop',a)
a = a + 1
else:
print('well done!')#没有break的情况下，循环没有被打断
# 输出
loop 0
loop 1
loop 2
loop 3
loop 4
loop 5
well done!a = 0
while a < 6:
print('loop', a)
a += 1
break # 有break的情况下，执行一次循环中止了，这种情况下不是正常中止的，else代码块是不执行的
else:
print('Well done!')
# 输出
loop 0
为了解决那些功能很简单的需求而设计的一句话函数
语法：lambda 参数列表 : 表达式
说明：使用lambda关键字创建匿名函数。所谓匿名函数，就是没有名字的函数。匿名函数冒号后面的表达式有且只能有一个，注意：是表达式，而不是语句。匿名函数自带return，而return的结果就是表达式的计算后的结果。
通过对比匿名函数和普通函数来说明下lambda的用法
1.无参匿名函数：
>>>t = lambda : True #分号前无任何参数
>>>t()
True
# 等价于
>>> def func(): return True
>>> func()
True 2.带参数匿名函数
>>> lambda x: x**3 #一个参数
>>> lambda x,y,z:x+y+z #多个参数
>>> lambda x,y=3: x*y #允许参数存在默认值
# 匿名函数调用
>>> c = lambda x,y,z: x*y*z
>>> c(2,3,4)
24
>>> c = lambda x,y=2: x+y #使用了默认值
>>> c(10) #不输的话，使用默认值2
12
>>> a = lambda *z:z # *z返回的是一个元祖，即返回的是和参数一样的类型
>>> a('Testing1','Testing2')
('Testing1', 'Testing2')
3.直接后面传递实参
>>> (lambda x,y: x if x> y else y)(101,102)
102
>>> (lambda x:x**2)(3)
9
# lambda返回的值，结合map,filter,reduce使用
>>> filter(lambda x:x%3==0,[1,2,3,4,5,6])
[3, 6]
# 等价于下面的列表推导式
>>> l = [x for x in [1,2,3,4,5,6] if x%3==0]
>>> l
[3, 6]4.嵌套使用
# lambda嵌套到普通函数中,lambda函数本身做为return的值
>>> def increment(n):
return lambda x: x+n
>>> f=increment(4)
>>> f(2)
6
>>> def say():
title = 'Sir,'
action= lambda x: title + x
return action
>>> act = say()
>>> act('Smith!')
'Sir,Smith!'5.大量例子
# 例01:字符串联合，有默认值，也可以x=(lambda...)这种格式
>>> x = (lambda x="Boo",y="Too",z="Zoo": x+y+z)
>>> x("Foo")
'FooTooZoo'
# 例02: 和列表联合使用
>>> L = [lambda x:x**2,\
lambda x:x**3,\
lambda x:x**4]
>>> for f in L:
... print f(2)
...
4
8
16
# 也可以如下面这样调用
>>> print L[0](3)
9
# 例03: 和字典结合使用
>>> key = 'B'
>>> dic = { 'A': lambda: 2*2,\
... 'B': lambda: 2*4,\
... 'C': lambda: 2*8}
>>> dic[key]()
8
# 例04: 求最小值
>>> lower = lambda x,y: x if x<y else y
>>> lower('aa','ab')
'aa'
# 例05: 和map及list联合使用
>>> import sys
>>> showall = lambda x:list(map(sys.stdout.write,x))
>>> showall(['Jerry\n','Sherry\n','Alice\n'])
Jerry
Sherry
Alice
>>> showall(['Jerry','Sherry','Alice'])
JerrySherryAlice
#等价于下面
>>> showall = lambda x: [sys.stdout.write(line) for line in x]
>>> showall(('I\t','Love\t','You!'))
I Love You![None, None, None]
# 例06: 在Tkinter中定义内联的callback函数
import sys
from Tkinter import Button,mainloop
x = Button(text='Press me',
command=(lambda:sys.stdout.write('Hello,World\n')))
x.pack()
x.mainloop()
>>>
Hello,World!
Hello,World!
# 例07: lambda和map联合使用,
>>> out = lambda *x: sys.stdout.write(' '.join(map(str,x)))
>>> out('This','is','a','book!\n')
This is a book!
# 例08: 判断字符串是否以某个字母开头
>>> print (lambda x: x.startswith('B'))('Bob')
True
>>> Names = ['Anne', 'Amy', 'Bob', 'David', 'Carrie', 'Barbara', 'Zach']
>>> B_Name= filter(lambda x: x.startswith('B'),Names)
>>> B_Name
['Bob', 'Barbara']
# 例09: lambda和map联合使用
>>> squares = map(lambda x:x**2,range(5))
>>> squares
[0, 1, 4, 9, 16]
# 例10. lambda和map,filter联合使用
>>> squares = map(lambda x:x**2,range(10))
>>> filters = filter(lambda x:x>5 and x<50,squares)
>>> filters
[9, 16, 25, 36, 49]
# 例11. lambda和sorted联合使用
# 按death名单里面，按年龄来排序
# 匿名函数的值返回给key，进来排序
>>> death = [ ('James',32),
('Alies',20),
('Wendy',25)]
>>> sorted(death,key=lambda age:age[1]) #按照第二个元素，索引为1排序
[('Alies', 20), ('Wendy', 25), ('James', 32)]
# 例12. lambda和reduce联合使用
>>> L = [1,2,3,4]
>>> sum = reduce(lambda x,y:x+y,L)
>>> sum
10
# 例13. 求2-50之间的素数
#素数:只能被1或被自己整除的数
>>> nums = range(2,50)
>>> for i in nums:
nums = filter(lambda x:x==i or x % i,nums)
>>> nums
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
# 例14. 求两个列表元素的和
>>> a = [1,2,3,4]
>>> b = [5,6,7,8]
>>> map(lambda x,y:x+y, a,b)
[6, 8, 10, 12]
#例15. 求字符串每个单词的长度
>>> sentence = "Welcome To Beijing!"
>>> words = sentence.split()
>>> lengths = map(lambda x:len(x),words)
>>> lengths
[7, 2, 8]
# 写成一行:
>>> print map(lambda x:len(x),'Welcome To Beijing!'.split())函数名的应用、闭包
函数名可以作为一个变量，函数的参数，函数的返回值，容器类类型的元素
1.作为一个变量
def func1():
print(666)
f1 = func1 # 这里函数名实际上是个变量，只是变量名改了而已
f2 = f1
>>>
f2()
6662.作为函数的参数
def func2(x):
print(x)
print('===', x())
print(func2(func1)) # 把func1的地址作为func2的参数，再执行func2函数。
>>>
<function func1 at 0x000001898B86FE18>
666
=== None
None3.函数名作为返回值
def wraaper():
def inner():
print('inner ')
return inner
ret = wraaper()
ret()
>>>
inner
'''
此时执行了inner()函数，为什么执行外部函数可以执行内嵌的函数呢，因为return了函数名，实际上形成了闭包。4.闭包
当return一个嵌入的函数名时，在全局命名空间就可以直接找到该函数的地址，也就是可以执行函数，原理是在全局变量空间外层的函数的内存地址指向了嵌入的函数的内存地址。通常要执行内层的函数时必须执行外层的函数才可以执行内嵌的函数，当外层函数return了内嵌的函数名，实际上把内嵌的函数地址放在外面了，就是告诉所有外部人，这就是我的地址，通过这个地址你们就可以找到我。
enumerate() 枚举函数
enumerate(iterable, start =0)
返回一个枚举对象，第一个参数必须是一个序列，一个迭代器，或者其他支持迭代的对象。用enumetate()利用iterator中next()的方法返回一个包含计数（默认从0）开始的以及从迭代中获得的值元组。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>>print(tuple(enumerate(seasons)))
>>>print(list(enumerate(seasons, start=4))) # 从4开始数
((0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter'))
[(4, 'Spring'), (5, 'Summer'), (6, 'Fall'), (7, 'Winter')] 
浙公网安备 33010602011771号