len(str) 判断字符串的字符数量
python 可执行和文件编码
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
字符串格式化
'Hi, %s, you have $%d.' % ('Michael', 1000000)
占位符 | 替换内容 |
---|---|
%d | 整数 |
%f | 浮点数 |
%s | 字符串 |
%x | 十六进制整数 |
format
'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
list与tuple的区别
list 数据类型列表 可以随时删除添加和修改其中的元素
tuple 元组 tuple和list非常相似,但是tuple一旦初始化就不能修改
条件语句
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
python 当中只有两种集合遍历
for .. in ..
while condition:
range(n) 生成序列是从0 开始小于 n 的整数
set 值不能重复
dict 键值对
isinstance() 判断变量属于那种类型
if not isinstance(x,(int ,float))
判断x变量是不是int 或者 float类型的变量
异常抛出
raise TypeError('bad operand type')
函数可以返回多个值
import math
def move(x,y):
a = x + 10
b = y + 20
return a,b
x,y = move(10,10)
print(x,y)
函数可以同时返回多个值,但其实就是一个tuple
函数参数
位置参数
默认参数
可变参数
关键字参数
命令关键字参数
参数组合
位置参数
def power(x):
return x * x
print(power(10))
默认参数
def power(x , n = 2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print(power(10))
print(power(10,3))
注意:
1.默认参数必须放在位置参数后面,不然Python解释器会报错
2.默认参数必须指向不变对象!
示例如下:
def addEnd(L = []):
L.append('END')
return L
print(addEnd())
print(addEnd())
print(addEnd())
def addEndAdvance(L = None):
if L is None:
L = []
else :
L.append('END')
return L
print(addEndAdvance())
print(addEndAdvance())
print(addEndAdvance())
可变参数
// 位置参数
def cale(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
//传入list
print(cale([1,2,3,4]))
//传入tuple类型
print(cale((1,2,3,4)))
//可变参数
def caleChangeParams(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
print(caleChangeParams(1,2,3,4,5))
关键字参数
关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。
def person(name,age,**kw):
print(name,age,kw)
person('zzx',22,city='beijing',country='china')
# out
zzx 22 {'city': 'beijing', 'country': 'china'}
[Finished in 0.1s]
命令关键字参数
- 后面的参数视为命令关键字参数,在传入关键字参数的时候关键字被指定
def person(name,age,*,city,country):
print(name,age,city,country)
print(person('zzx',22,city='wuhan',country='china'))
print(person('zzx',22,city1='wuhan',country2='china')) //这句话将报错
组合参数
def func(*args,**kw):
print(args,kw)
func('zzx','wuhan',sex='M',school='wtu',city='wh')
高级特性
切片
对经常取指定索引范围的操作,用循环十分繁琐,因此,Python提供了切片(Slice)操作符,能大大简化这种操作。
L = ['A','B','C','D','E','F','G','H','I','J','K','L']
L[0:3]
L[:3]
L[2:3]
L[::3] 每隔3个数去一个数
L[-1:-4] 倒数第一个到倒数第4个
'ABCDEFGHIJKL'[0:3] 字符串营业可以当做list
迭代
test
for item in list|set:
dict 迭代方式
默认迭代key
for k in dict:
迭代value
for value in dict.values():
同时迭代key,和value
for k,v in dict.items()
注意:for循环时,只要作用于一个可迭代对象,for循环就可以正常运行,而我们不太关心该对象究竟是list还是其他数据类型。
判读一个对象是否可以迭代方式:
from collections import Iterable
isinstance('abc',Iterable) True
isinstance([1,2,3],Iterable) True
isinstance(123,Iterable) False
如果要对list实现类似Java那样的下标循环怎么办?Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身
L = ['A','B','C','D','E','F','G','H','I','J','K','L']
for i,value in enumerate(L):
print(i,value)
列表生成式
列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式。
//生成1-10的数字
L = list(range(1, 11))
//生成1-10每个数的平方和
L = [x * x for x in range(1, 11)]
//生成偶数的平方列表
L = [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
//双层循环
[m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
//列出当前目录下的所有文件和目录名,可以通过一行代码实现:
import os # 导入os模块,模块的概念后面讲到
[d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['Desktop', 'Documents', 'Downloads', 'Library', ...]
//列表生成式可以使用两个变量生成列表
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
//把所有的大写变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']
生成器
性能问题:在Python中,这种一边循环一边计算的机制,称为生成器:generator。
#要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:
g = (x * x for x in range(10))
g
<generator object <genexpr> at 0x1022ef630>
注意:
1.generator保存的是算法,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。
2.generator是可以用for 循环遍历的而且还不用担心StopIteration问题
将函数变成generate
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
# change ,要把fib函数变成generator,只需要把print(b)改为yield b就可以了
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
#调用方式
f = fib(6)
next(f)
迭代器
我们已经知道,可以直接作用于for循环的数据类型有以下几种:
一类是集合数据类型,如list、tuple、dict、set、str等;
一类是generator,包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象:Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象:
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
而生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了。
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数:
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
你可能会问,为什么list、dict、str等数据类型不是Iterator?
这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。
注意
小结
凡是可作用于for循环的对象都是Iterable类型;凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;
集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的,例如:
for x in [1, 2, 3, 4, 5]:
pass
#实际上完全等价于:
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
高阶函数
高阶函数英文叫Higher-order function
1.变量可以指向函数
2.函数名也是变量
3.传入函数
def myAbs(x):
if x > 0:
return x
else :
return -x
def add(x,y,f):
return f(x)+f(y)
add(-1,-10,f)
注意:
把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式。
map
map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
map()传入的第一个参数是f,即函数对象本身。由于结果r是一个Iterator,Iterator是惰性序列,因此通过list()函数让它把整个序列都计算出来并返回一个list。
应用
#将列表中的所有数字转化成字符串
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8',
reduce
再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, …]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
filter
Python内建的filter()函数用于过滤序列。
和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
#在一个list中,删掉偶数,只保留奇数
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]
#filter
阅读: 308863
Python内建的filter()函数用于过滤序列。
和map()类似,filter()也接收一个函数和一个序列。和map()不同的是,filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
例如,在一个list中,删掉偶数,只保留奇数,可以这么写:
def is_odd(n):
return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]
把一个序列中的空字符串删掉
def not_empty(s):
return s and s.strip()
list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
# 结果: ['A', 'B', 'C']
sorted
排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。如果是数字,我们可以直接比较,但如果是字符串或者两个dict呢?直接比较数学上的大小是没有意义的,因此,比较的过程必须通过函数抽象出来。
#Python内置的sorted()函数就可以对list进行排序:
>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
#sorted()函数也是一个高阶函数,它还可以接收一个key函数来实现自定义的排序,例如按绝对值大小排序:
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
返回函数
高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
闭包
当一个函数返回了一个函数后,其内部的局部变量被新函数所引用
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
#结果
>>> f1()
9
>>> f2()
9
>>> f3()
9
分析
全部都是9!原因就在于返回的函数引用了变量i,但它并非立刻执行。等到3个函数都返回时,它们所引用的变量i已经变成了3,因此最终结果为9。
注意:返回闭包时牢记一点:返回函数不要引用任何循环变量,或者后续会发生变化的变量。
改进
def count():
def f(j):
def g():
return j*j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
return fs
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9
缺点是代码较长,可利用lambda函数缩短代码。
匿名函数
不需要显式地定义函数
lambda x: x * x
-----------------
def f(x):
return x * x
装饰器
函数也是一个对象,而且函数对象可以被赋值给变量,所以,通过变量也能调用该函数
函数对象有一个name属性,可以拿到函数的名字
代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)
>>> def now():
... print('2015-3-25')
...
>>> f = now
now.__name__ #'now'
test
test
test
test
test
test
test
test
test
test