数据类型

基本数据类型:
整型(int),浮点型(float),字符串(str),列表(list),元组(tuple),字典(dict),集合(set),布尔(bool)

数值类型(整数,浮点,布尔)
序列类型(字符串,列表,元组)
散列类型(字典,集合)

字节类型 a=bytes(‘123’)/a=b’123’
字节数组bytearrary(‘123’)

可变序列:列表,集合,字典
不可变序列:字符串,元组

数据类型方法

—字符串方法

增:
字符串拼接
1.str1+str2+str3
2.””.join([str1,str2,str3])
3."%s %s %s"%(str1,str2,str3)
4."{} {} {}".format(str1,str2,str3)

删:
x.replace(m,n,x) m:准备替换的内容 n:替换的内容 x:替换的个数

查:
x.index(m) m:索引的内容
x.find(m) m:索引的内容
x.count(m) m:计数的内容
x.isdigit() x是否是数字
x.isalpha() x是否是字母
x.isupper() x是否是大写
x.islower() x是否是小写
x.startswith(m) x是否以m开头
x.endswith(m) x是否以m结尾

改:
x.upper() x转化为大写
x.lower() x转化为小写
x.strip()去x左右空白/lstrip去左空白/rstrip去右空白
x.title() x标题化
x.capitalize() x第一个字母大写
x.split(m,x) 以m为界分割 分割x次

—列表方法

增:
li.append(m) m:添加的内容
li.insert(x,m) x:元素下标位置 m:插入的内容
li.extend(list) list:为另一个列表

删:
li.pop(x) x:删除一个元素并返回该元素的值 若无参数x则从最后开始删除
li.remove(m) m:需要删除的内容
li.clear() 清空列表li

查:
li.index(m) m:索引的内容
li.count(m) m:计数的内容

改:
list[n]=x

其他:
copy() 浅复制
import copy 深复制 适用于两层列表
list1=copy.deepcopy(list2)
永久排序
li.sort(reverse=True/False) m:列表 True倒排序 False正排序
m.reverse() 永久倒排序
临时排序
sorted(li,reverse=True/False) m:列表 True倒排序 False正排序
reversed(m) 临时倒排序

—元组方法

查:
t.index(m) m:索引的内容
t.count(m) m:计数的内容

—集合方法

交集& 并集| 差集-

增:
a.add(m) m:向集合里面添加的内容
删:
a.pop() 随机删除集合内容
a.remove() 指定删除集合内容
查:
a.isdisjoint(b) a与b是否存在交集
a.issubset(b) a是b的子集吗
a.issuperset(b) a是b的父集吗
改:
a.update(m) 向集合里面添加元素m可以为字符串 列表 元组 集合 字典

—字典方法

增:
d=dict.fromkeys(m,n) m:键的来源可迭代对象 n:设置值的默认值
d.setdefault(m,n) 查询有则返回无则添加m:键 n:值

删:
d.clear() 清空字典
d.pop(m) m:键 删除以m为键的字典
d.popitem() 删除最后一个字典

改:
d.update(m) m:添加的字典
dic[m]=n m:键 n:值

查:
d.get(m) m:键 返回m键对应的值
d.keys() 获得键的列表
d.values() 获得值的列表
d.items() 同时获得键与值的元组 再通过遍历获得键与值

判断类型:type() isinstance(变量,类型)

运算符及其优先级

运算符说明
** ^ !指数 按位翻转 非
* / % //乘 除 取模 整除
+ -加 减
>> <<右移 左移
== >= <= > < !=是否 /等于 大于等于 小于等于 大于 小于 不等于
= += -= *= /= %= **= //=赋值
is is not判断内存地址是否相同
in not in判断成员是否存在
and or not与 或 非
流程控制

if-else
语法:

if 条件:
语句
else:
语句
1
2
3
4
例子:

a=1
#使用方式一
if a>1:
print('大于1')
else:
print('小于等于1')
#使用方式二
print('大于1') if a>1 else print('小于等于1')
输出:
>>小于等于1
>>小于等于1
1
2
3
4
5
6
7
8
9
10
11
if-elif-else
语法:

if 条件:
语句
elif 条件:
语句
else:
语句
1
2
3
4
5
6
例子:

a=1
if a>1:
print('大于1')
elif a<1:
print('小于1')
else:
print('等于1')
输出:
>>等于1
1
2
3
4
5
6
7
8
9
while
语法:

while 条件:
语句
1
2
例子:

a=5
while a>0:
print(a)
a-=1
输出:
>>5
>>4
>>3
>>2
>>1
1
2
3
4
5
6
7
8
9
10
while-else
语法:

while 条件:
语句
else:
循环结束后执行的语句
1
2
3
4
例子:

a=5
while a>0:
print(a)
a-=1
#循环中若出现break则跳出循环,且不再执行else中的语句
else:
print('ok')
输出:
>>5
>>4
>>3
>>2
>>1
>>ok
1
2
3
4
5
6
7
8
9
10
11
12
13
14
for循环

for i in 可迭代对象:
语句
1
2
例子:实现九九乘法表

for i in range(1,10):
for j in range(1,i+1):
print(str(i)+'x'+str(j)+'='+str(i*j),end=' ')
print('\n',end='')
输出:
>>1x1=1
>>2x1=2 2x2=4
>>3x1=3 3x2=6 3x3=9
>>4x1=4 4x2=8 4x3=12 4x4=16
>>5x1=5 5x2=10 5x3=15 5x4=20 5x5=25
>>6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36
>>7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49
>>8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64
>>9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
1
2
3
4
5
6
7
8
9
10
11
12
13
14
函数

—函数的定义

定义函数

def myfunc(x):
if x >= 0:
return x
else:
return -x
1
2
3
4
5
空函数

def emptyfunc():
pass
1
2
参数检查

def checkfunc(x):
if not isinstance(x,(int,float)):
raise TypeError("must be int or float type!")
if x >= 0:
return x
else:
return -x
1
2
3
4
5
6
7
返回多个值

def price(x):
apple=x*2
banana=x*2.5
return apple,banana
a,b=price(1)
1
2
3
4
5
函数返回多值其实就是返回一个元组
—函数的参数

必选参数parameter

def printdetail1(name,age,telephone):
print("姓名:",name)
print("年龄:",age)
print("电话:",telephone)
printdetail1("Jack",12,12356435678)
1
2
3
4
5
默认参数parameter=value

def printdetail2(name,age,telephone,gender='fale'):
print("姓名:",name)
print("性别:",gender)
print("年龄:",age)
print("电话:",telephone)
printdetail2("Jack",12,12356435678,gender='female')
1
2
3
4
5
6
可变参数*
1.不定长传参

def fun1(*number):
for i in number:
print(i)
fun1(1,2,3,4,5,6,7,8)
1
2
3
4
2.元组和列表的压包

def fun2(*number):
s=0
for i in number:
s+=i
print(s)
fun2(*[1,2,3,4,5])
fun2(*(1,2,3,4,5))
1
2
3
4
5
6
7
关键参数**
使用方法一

def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",sex="man",age='12')
1
2
3
4
5
使用方法二

extra={'sex': 'man', 'age': 12}
def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",sex=extra['sex'],age=extra['age'])
1
2
3
4
5
6
使用方法三

extra={'sex': 'man', 'age': 12}
def fun(id,name,**kargs):
print("id:",id)
print("name:",name)
print("others:",kargs)
fun(2,"xiaohua",**extra)
1
2
3
4
5
6
关键字参数*

def fun(name,age,*,city,job,completion):
print("name:",name)
print("age:",age)
print("city:",city)
print("job:",job)
print("completion:",completion)
fun('Jack',12,city='shanghai',job='teacher',completion=True)
1
2
3
4
5
6
7
命名关键字参数需要一个特殊分隔符*,后面的参数被视为命名关键字参数
如果函数定义中已经有了一个可变参数,后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
参数组合

def fun(parameter,*args,keyparameter,**kargs):
print(parameter)
print(args)
print(keyparameter)
print(kargs)
fun(1,*(1,2,3,4),keyparameter=True,**{'id':2})
1
2
3
4
5
6
参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数
—函数的递归

#阶乘计算
def fact(n):
if n == 1:
return 1
return n * fact(n-1)
1
2
3
4
5
必须设置函数终止条件
使用递归函数的优点是逻辑简单清晰,缺点是过深的调用会导致栈溢出。
函数作用域
1.外部不能访问函数内部变量
2.函数内部能够访问函数外部变量
3.函数里面不能修改函数外部变量(若要修改需声明global x x=n)
4.函数里面和函数外部变量名相同

函数式编程

—高阶函数

map()
map(函数名,列表/元组/集合/字符串)

a='12345'
def square(x):
return int(x)*int(x)

b=list(map(square,a))
print(b)
输出:
>>[1, 4, 9, 16, 25]
1
2
3
4
5
6
7
8
map()把传入的函数依次作用于每个元素,处理完后返回的是生成器类型,需要用list生成数据
filter()
filter(函数名,列表/元组/集合/字符串)

a=[1,2,3,4,5,6,7,8,9,10]
def even_number(x):#筛选偶数
return x%2==0
b=list(filter(even_number,a))

print(b)
输出:
>>[2, 4, 6, 8, 10]
1
2
3
4
5
6
7
8
a=['A', '', 'B', None, 'C', ' ']
def remove_blank(x):#去除空元素
return x and x.strip()

b=list(filter(remove_blank,a))
print(b)
输出:
>>['A', 'B', 'C']
1
2
3
4
5
6
7
8
filter()把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素,处理完后返回的是生成器类型,需要用list生成数据
—返回函数

def delay_sum(*args):
def sumfunc():
s=0
for i in args:
s+=i
return s
return sumfunc
f=delay_sum(1,2,3,4)
print(f())
输出:
>>10
1
2
3
4
5
6
7
8
9
10
11
—函数的闭包

def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs

f1, f2, f3 = count()
print(f1())
print(f2())
print(f3())
输出:
>>9
>>9
>>9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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()
print(f1())
print(f2())
print(f3())
输出:
>>1
>>4
>>9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
—匿名函数

lambda 形参:含形参的表达式

f = lambda x:x+1
print(list(map(f,[1,2,3,4,5])))
输出:
>>[2, 3, 4, 5, 6]
1
2
3
4
lambda返回的是函数地址
lambda常与map函数联用
—装饰器

装饰器:我们要增强函数的功能,比如,在函数调用前后自动打印日志,但又不希望修改函数的定义,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)
定义装饰器

def decorator(func):
def wrapper(*args,**kargs):#可以自行定义传入的
print(func,__name__)
return func(*args,**kargs)
return wrapper
1
2
3
4
5
使用装饰器

#使用方法一
now=decorator(函数名)#装饰器不传入参数时
now=decorator(参数)(函数名)#装饰器传入参数时
now()#执行被装饰过的函数

#使用方法二
@decorator#已定义的装饰器
def f():#自定义函数
pass
f()#执行被装饰过的函数
1
2
3
4
5
6
7
8
9
10
自身不传入参数的装饰器

def login(func):
def wrapper(*args,**kargs):
print('函数名:%s'% func.__name__)
return func(*args,**kargs)
return wrapper
@login
def f():
print('inside decorator!')
f()
输出:
>>函数名:f
>>函数本身:inside decorator!
1
2
3
4
5
6
7
8
9
10
11
12
自身传入参数的装饰器

def login(text):
def decorator(func):
def wrapper(*args,**kargs):
print('%s----%s'%(text,func.__name__))
return func(*args,**kargs)
return wrapper
return decorator

@login('this is a parameter of decorator')
def f():
print('2019-06-13')
f()
输出:
>>this is a parameter of decorator----f
>>2019-06-13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
内置装饰器
@property:就像访问属性一样和普通访问少了一个()
@staticmethod: 静态方法和class类断开联系 既可以先实例化再调用也可以直接调
@classmethod: 类方法 接调用调用函数Rectangle.func()

class Rectangle:
def __init__(self, length, width):
self.length = length
self.width = width

@property # 就像访问属性一样和普通访问少了一个()
def area(self):
return self.width * self.length