- Python可变类型与不可变类型
不可变类型：数字、字符串、元组
可变类型：列表、字典、集合 - 浅拷贝和深拷贝
浅拷贝：新旧对象共享一块内存，拷贝父对象，不拷贝对象内部的子对象
深拷贝：为数据重新开辟一块空间，修改新对象不会改变原对象
import copy
#浅拷贝
arr=[1,2,3,[4,5,6]]
arr2=arr.copy()
arr2[0]=10
arr2[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr2)#[10, 2, 3, [40, 5, 6]]
arr=[1,2,3,[4,5,6]]
arr3=arr[:]
arr3[0]=10
arr3[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr3)#[10, 2, 3, [40, 5, 6]]
arr=[1,2,3,[4,5,6]]
arr4=copy.copy(arr)
arr4[0]=10
arr4[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr4)#[10, 2, 3, [40, 5, 6]]
#深拷贝
arr=[1,2,3,[4,5,6]]
arr5=copy.deepcopy(arr)
arr5[0]=10
arr5[3][0]=40
print(arr)#[1, 2, 3, [4, 5, 6]]
print(arr5)#[10, 2, 3, [40, 5, 6]]
- Python字符串去重并排序
s='abcabcefefabczzx'
s=list(s) #转成列表
s=set(s) #去重
s=list(s) #转回列表
s.sort() #排序
s=''.join(s)#转回字符串
print(s) #输出:abcefxz
- Python交换两个变量的值
a='abc'
b='cdf'
a,b=b,a
print(a,b) #输出:cdf abc
- Python提取列表中的数字
s=[123,'a','b',234,2,5,'abc']
s=list(filter(lambda x:type(x)==int,s))
print(s)
- pip是什么?
python包管理器/模块管理器 - pip常用指令
pip list
pip install
pip uninstall - 隔离环境的目的
为了让每个应用有独立的运行环境 - pyhton中的注释
单行#注释，
多行```注释``，
"""注释""" - python2.x和python3.x的区别
- 编码
python2.x默认ASCII 要加# -*- coding：UTF-8
python3.x默认unicode - print
print加不加括号的区别 - input
2.x input返回数值类型
raw_input返回字符串类型
3.x input返回字符串类型 - range
2.x 返回列表
3.x 返回迭代器
- 编码
- 多行语句用\隔开，或者()
- 为什么很多人说python弱类型？
声明不需要指定,表面弱类型,实际很严格 - python中的数据类型
在python中常用的数据类型:数值 字符串 列表 元组 字典 集合
在python中有多少种数据类型:除了以上标准的,还有int long float bool等 - type()返回的结果是什么?
如果只有第一个参数，返回对象的类型，如果有三个参数返回新的类型对象 - isinstance() 与 type() 区别
type() 不认为子类是一种父类类型，不考虑继承关系
isinstance() 会认为子类是一种父类类型，考虑继承关系 - int(1.4)和int('1.4')什么结果?
int(1.4)结果:1，int('1.4')报错 - 保留两位小数round(m,2),a=3.1415926保留两位小数
a=3.175
print('%.2f'%a)
b=round(a,2)#四舍五入,小数点后奇数+5不进1，偶数+5进1
print(b)
def num2(n):
arr = str(n).split('.')
point = arr[1][0:2]
num = arr[0] + '.' + point
return num
a=num2(1.12212)
print(a)
- bool类型
print(bool('False'))#True
print(bool(0))#False
print(bool([1,2]))#True
print(bool([]))#False
print(bool({}))#False
print(bool(None))#False
- set类型
a={}
b=set()
c={1}
print(type(a))#<class 'dict'>
print(type(b))#<class 'set'>
print(type(c))#<class 'set'>
- repr(x)的区别str(x)
数值、列表、字典输出相同
repr(x)便于编译理解,转成表达式字符串
str(x)便于程序员理解,转成字符串
a='hello\n'
print(str(a)) #hello+换行
print(repr(a)) #'hello\n'
a='1000L'
print(str(a)) #1000L
print(repr(a)) #'1000L'
#1000L长整型
- 哪些是可变类型,哪些是不可变类型,区别是什么
可变:列表,字典,集合
不可变:元组,字符串,数值
arr=[1,2,3,4]
s='abcd'
arr[1]=20
print(arr) #[1, 20, 3, 4]
s[1]='d' #TypeError: 'str' object does not support item assignment
print(arr)
- s=r'\n' 字符串前加r与普通字符串几乎相同的语法
- 切片
- 第一个 s[0]
- 最后一个 s[-1]
- 2-4 s[1:4]
- 2-最后 s[a:]
- 步长2 s[1:10:2]
- 字符串反转 s[::-1]
- 内建函数
- count()统计一个字符串出现的次数
- find()检测字符串中是否包含子串,有返回索引值,否则返回-1
- replace()替换
- 去空格
s=' abc def '
print('**'+s.lstrip()+'**')#**abc def **
print('**'+s.rstrip()+'**')#** abc def**
print('**'+s.strip()+'**')#**abc def**
print('**'+s.replace(' ','')+'**')#**abcdef**
import re
s=' abc def '
s=re.sub(r'\s','',s)
print('**'+s+'**')
- split()字符串拆分成数组
- join()数组拼合并成字符串
s1='abc'
s2='123'
s3=['x','y','z']
print(s1.join(s2))
print(s1.join(s3))
- 判断
- isdigit()判断是否是纯数字
- isalpha()判断是否是纯字母
- isalnum()判断是否是字母或数字
- upper()转大写
s1='123'
s2='abc'
s3='abc123'
print(s1.isdigit())#True
print(s2.isalpha())#True
print(s3.isalnum())#True
- 列举常用的五个模块
os,re,math,datetime,urllib,request - dir()和help()
dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表
dir()带参数时，返回参数的属性、方法列表
help()查看函数或模块用途的详细说明 - 取整
floor()向下取整
ceil()向上取整
trunc()截断小数位
import math
a=1.345
b=-1.567
print(int(a))#1
print(math.floor(a))#1
print(math.ceil(a))#2
print(int(b))#-1
print(math.floor(b))#-2
print(math.ceil(b))#-1
print(math.trunc(a))#1
- 随机排序
import random
arr=[1,2,3]
random.shuffle(arr)
print(arr)
- 列表
count()判断是否存在
append()添加元素
extend()增加集合
insert()插入元素
remove()删除一个具体元素
del 删除一个具体元素
clear()清空
append+pop()栈
append+popleft队列 - 判断是否存在
s='abcd'
print(s.count('a'))#1找不到不会报错
print(s.index('a'))#0找不到会报错
print(s.find('a'))#0
print('a' in s)#True
- 列表
sort()
reverse() - 内置函数
map
filter
reduce
sorted - 列表推导式
取偶数
arr = [1, 2, 6, 3, 1]
arr2 = [i for i in arr if i % 2 == 0]
print(arr2)
二维转一维
arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[]
for i in arr:
for j in i:
arr2.append(j)
print(arr2)
arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[i for j in arr for i in j]
print(arr2)#[1, 2, 3, 4, 5, 6, 7, 8, 9]
按列取
arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[[e[i] for e in arr] for i in range(len(arr))]
print(arr2)#[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
- 查看地址
arr=[1,2,3]
print(id(arr))
- 垃圾回收机制
- 小对象对象池
- -5-256
- 数字字母下划线
- 长度不能大于20
import sys print(sys.getrefcount(3)) a=3 print(sys.getrefcount(3)) b=3 print(sys.getrefcount(3)) - 大对象对象池
- 作用域内部才等
- python中引用计数器如果是0,垃圾回收机制把它扫掉
- 小对象对象池
- 垃圾回收
c、c++用户自己管理维护内存
java,c#垃圾回收机制
python的垃圾回收机制采用引用计数器
ruby:标记删除
优点:实时性 处理回收内存时间分摊到平时
缺点:维护引用计数器耗资源
垃圾回收机制工作:为新生的对象分配内存,识别垃圾,清理垃圾 - 字典的遍历
goods={
"id":'001',
"price":20
}
for i in goods:
print(i)
#id
#price
for k,v in goods.items():
print(k,v)
# id 001
#price 20
for k in goods.keys():
print(k)
#id
#price
for v in goods.values():
print(v)
#001
#20
- get()
goods={
"id":'001',
"price":20
}
print(goods.get('id'))#001
- pop()
goods={
"id":'001',
"price":20
}
goods.pop('id')
print(goods)#{'price': 20}
- 字典的合并
goods={
"id":'001',
"price":20
}
goods2={
"num":9
}
goods.update(goods2)
print(goods)#{'id': '001', 'price': 20, 'num': 9}
- 字典字符串转换
import json
json.dumps(dict)#字典->字符串
json.loads(str)#字符串->字典
- 元组
一旦创建不可改变，但可以切片
arr=(1,2,3)
a,*b=arr
print(type(a))#<class 'int'>
print(type(b))#<class 'list'>
- 集合
不重复
s={1,2,3,3,3,3,3}
print(s)#{1, 2, 3}
添加add()
s={1,2,3}
s.add(4)
print(s)#{1, 2, 3, 4}
移除discard()、remove()、pop()
s={1,2,3}
s.discard(2)
print(s)#{1, 3}
s.discard(4)#移除不存在的元素不会报错
s={1,2,3}
s.remove(2)
print(s)#{1, 3}
s.remove(4)#KeyError: 4
- 交集、并集
intersection()
union() - 合并并更新
update() - zip()迭代器
s=['a','b','c']
s2=[1,2,3]
s3=zip(s,s2)
print(list(s3))#[('a', 1), ('b', 2), ('c', 3)]
- enumerate()
s=['a','b','c']
for (index,item) in enumerate(s):
print(index,item)
#0 a
#1 b
#2 c
print(list(enumerate(s)))#[(0, 'a'), (1, 'b'), (2, 'c')]
- 迭代器
字符串/数组本身没有迭代对象，for循环自动加上迭代器
s='hi cat'
i=iter(s)
print(i.__next__())#h
print(i.__next__())#i
print(i.__next__())#
print(i.__next__())#c
print(i.__next__())#a
print(i.__next__())#t
- 生成器
- 推导式写成()
- yield
L=[x*x for x in range(10)]
G=(x*x for x in range(10))
print(L[-1])#81
while True:
try:
print(G.__next__())
except StopIteration:
break
- 可选参数、关键字参数
def add(a,b=2,*c):
print(c)
add(1,2,[5,6,7])#([5, 6, 7],)
add(1,2,*[5,6,7])#(5, 6, 7)
def add(a,b=2,*c,**d):
print(c,d)
add(1,2,*[5,6,7],id='001')#(5, 6, 7) {'id': '001'}
add(1,2,*[5,6,7],**{'id':'001','price':'95'})#(5, 6, 7) {'id': '001', 'price': '95'}
- lambda
s=[1,2,3,4]
def add(i):
return i+2
s2=map(add,s)
print(list(s2))#[3, 4, 5, 6]
s2=map(lambda i:i+2,s)
print(list(s2))#[3, 4, 5, 6]
from functools import reduce
s=[1,2,3,4]
s2=reduce(lambda x,y:x*y,list(range(1,6)))
print(s2)
- Python中global和nonlocal的区别
global:在函数或其他局部作用域中使用全局变量
nonlocal:在函数或其他作用域中使用外层(非全局)变量
a=1
def add(x):
global a
a=a+1
global c#局部变量全局化
c=2
return x+a
print(add(2))#4
print(c)#2
a=1
def add(x):
a=2
def sub():
global a
a=a+x
return a
return sub()
print(add(200))#201
a=1
def add(x):
a=2
def sub():
nonlocal a
a=a+x
return a
return sub()
print(add(200))#202
- 查询和替换一个文本字符串
replace(替换成的字符串,要被替换的字符串,最多替换次数)
a = 'aaabbbccc'
b = a.replace('b','d',3)
print(b) #aaadddccc
re.sub(正则表达式,替换成的字符串,原字符串,替换次数)
import re
s1 = 'aaabbbccc'
print(re.sub(r'b','d',s1,count=1)) #输出:aaadbbccc
#或者
import re
s2 = 'aaabbbccc'
reg = re.compile(r'b')
print(reg.sub('d',s2,count=4))#输出:aaadddccc
- match()和search()的区别
- match()从字符串的开始匹配，匹配不成功返回None
- search()在字符串内匹配，只找到第一个匹配并返回，匹配不成功返回None
- __new__() 与__init__()的区别
__new__作用于__init__()之前
__init__ 是实例级别的方法，通常用于初始化一个新实例。
__new__是类级别的方法，通常用于控制生成一个新实例的过程。 - 列举几种设计模式
工厂方法模式：定义一个创建对象接口，通过子类来创建对象。
单例模式：一个类仅有一个实例，例如框架中的数据库连接 - 闭包
内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用
def a(s):
def b(s):
print(s)
return b(s)
a('123')
- 回调
把函数作为参数传递给另一个函数
def a(s):
print(s)
def b(func):
func('123')
b(a)
- Python字符串的编码与解码
decode将其他编码转unicode编码
encode将unicode编码转其他编码
s1='abc'
s2=s1.encode('utf-8') #utf-8编码转unicode编码
print(s2) #输出:b'abc'
s1=s2.decode('utf-8') #unicode编码转utf-8编码
print(s1)#输出:abc
- 装饰器的作用
在不改变函数本身的情况下，为函数增加新的功能 - 列举HTTP请求中的状态码
200 访问成功
302 重定向
404 请求的url不存在
500 服务器端错误
505 HTTP版本不受支持 - Flask蓝图的作用
使不同的功能模块化
优化项目结构
增强可读性，易于维护 - Python生成随机数
- Python生成随机数
random.randrange(起始位置,结束位置,步长)
import random
print(random.randrange(10))
print(random.randrange(100,200))
print(random.randrange(300,400,50))
- 在一个范围内,生成不重复的随机数
s=random.sample(范围,生成数量)
import random
print(random.sample(range(0,5),3))
print(random.sample([1,2,3,4,5],3))
- import 和 from import的区别
import 导入整个模块，每次使用模块中的函数时需要确定是哪个模块
from import 创建 一个副本，导入模块中的函数，可以直接使用 - Python解释器对模块位置的搜索顺序
当前主目录、PYTHONPATH下的每个目录、标准第三方链接库、.pth文件 - 静态方法和类方法的关键字
静态方法: @staticmethod
类方法:@classmethod - Python主要特点和优点
可解释
具有动态特性
面向对象
简明简单
开源
具有强大的社区支持 - Python的自省
运行时能够获得对象的类型。
如：type() dir() getattr() hasattr() isinstance() - Python中的但双下划线
单下划线用处：解释器中、名称、i18n
单下划线前缀的名称：受保护的，仅能内部访问
双下划线前缀的名称：私有的，仅类对象自己能访问（子类也不能访问）
双下划线开头加结尾：Python系统自带的一些函数和方法
