'''
python基础
变量的定义
变量名 = 变量值
变量名的命名规范：
字母、数字、下划线组合
不能以数字开头
不能命名关键字
变量的三大特性
id() 变量值在内存中的地址、
type() 变量值的数据类型、
value() 变量值本身
常量的定义
在python中并没有明确规定常量的定义语法，我们一般以变量名全大写作为常量的命名
常量就是在整个py文件的执行过程中都不会发生改变的值
数字类型number
int：整型
int(x, base) 将unicode、数字转换为十进制，base指定x的进制类型，默认10
float：浮点型
float(number) 将number转换为float
complex：复数
complex(number) 将number转换为complex
进制转换（内置函数）
oct(number) 转换为八进制 0o
hex(number) 转换为十六进制 0x
bin(number) 转换为二进制 0b
字符串string
字符串的增删改查
字符串是不可变数据类型（对于字符串的修改操作都不是完全生效的）
查看：
下标方式 str[index]
切片 str[start:end:step]
str.find(x, start, end) 返回x在字符串中的下标值，不存在则返回-1
str.rfind()
str.index(x, start, end) 返回x在字符串中的下标值，不存在则报错
str.rindex()
str.count(x, start, end) 返回x在字符串中的出现次数，不存在则返回0
str.startswith(x, start, end) 判读x是否是字符串的首位
str.endswith(x, start, end) 判断x是否是字符串的末尾
str.isalpha() 纯字母
str.isupper() 纯大写字母
str.islower() 纯小写字母
str.istitle() 每个单词首字母大写，单词内字母小写
str.isnumber() 字母 or 数字
str.isdigit() bytes、unicode
str.isdecimal() unicode
str.numeric() unicode、中文数字、罗马数字
str.isspace() 纯空白字符
修改：
str.replace(old, new, count) 替换str中old字符为new字符
str.split(x, maxsplit=-1) 以x作为分隔符，返回列表
str.rsplit(x, maxsplit=-1)
str.partition(x) 以x为根，分割为 x前、x、x后，返回一个元组
str.rpartition(x)
str.ljust(width, x) str在左
str.rjust(width, x) str在右
str.center(width, x) str在中间
str.zfill(width)
str.lower()
str.upper()
str.title()
x.join(iterable)
x.expandtabs(x=8)
str.strip(x)
str.lstrip(x)
str.rstrip(x)
格式化字符串
%s %d %f %nd %-nd %'字符'nd %.nf %X %x %%
{}{number}{变量名}.format()
转义字符
\\ \' \" \t \n r'' R''
列表list
列表的增删改查
增加
list.append(obj)
list.insert(index, obj)
list.extend(iterable)
删除
list.remove(x)
list.clear()
list.pop(index) 返回value
del list
修改
list[index] = value
查看
list[index]
list.index(x)
len(list)
in not in
list.count(x)
列表的排序
[::-1]
list.reverse()
list.sort(key=func, reverse=True)
sorted(iterable, key, reverse)
列表推导式
[i for i in range(1, 10) if i ==2]
[(x, y) for x in range(1, 10) for y in range(10, 20)]
元组tuple
增加
+
查询
in not in
tuple.index(vlaue) index
len(tuple)
tuple.count(value)
元组的注意事项
1. (x,)
2. 1,2,3,4
集合set
集合无序
集合去重
集合对于纯数字，自动排序
集合的增删改查
增加
set.add(element)
set.union(set2)
set.update(iterable)
删除
set.clear()
set.remove(value)
set.pop()
del set
查看
len(set)
集合与运算符
- & | ^ > >= < <=
字典dictionary
key：不可变数据类型
字典的增删改查
增加
dict1.update(dict2)
dict[key] = value
查看
len()
in not in
dict.keys()
dict.value()
dict.items() dict_items[(k, v),...]
修改
dict[key] = value
setdefault(key, default=None)
fromkeys([k], v)
删除
dict.clear()
del dict
dict.pop(index) value
dict.popitem() (k, v)
布尔boolean
空字典、字符串、列表、集合、元组、False、<=0、None、
通用方法
内置函数
str(obj)
list(iterable)
tuple(iterable)
set(iterable)
bool(obj)
dict(**kwargs, [(),...])
enumerate(iterable)
len()
算术运算符
+ list、string、tuple
- set
* list、string、tuple
in dict、set、string、tuple、list
not in dict、set、string、tuple、list
字符编码集
ord(字符) unicode编码值
chr(编码值) unicode字符
encode('编码规则') 编码
decode('编码规则') 解码
ASCII码表
UNICODE码表
utf8 简体中文、中文占三字节
gbk 简体中文、中文占两字节
big5 繁体中文
垃圾回收机制
堆区：存放变量值的
栈区：存放变量名与变量值的关联关系
直接引用：从栈区出来直接就是变量值
间接引用：从栈区出来需要经过中转才能获取到变量值
在python中，当我们定义变量名的时候，都会想内存申请一块内存空间来存放变量值，并将变量值所在内存的地址返回给变量名实现映射关系
我们因该实现，当变量值不再被使用时，回收变量值所占的内存空间
引用计数：
当一个变量值，不管是被直接引用还是间接引用时，引用计数加1
当引用计数为0时，变量值所在内存空间因该被回收
循环引用：容器对象
效率问题
标记清除：
当py文件执行完毕，或者内存空间占满时，应停止程序，执行以下步骤：
遍历整个栈区，对于栈区内存在引用的变量值标记为存活
遍历整个堆区，回收不存活的变量值
分代回收：
周期性遍历栈区，对于多次扫描下，依然存活的变量值，归于下一代
在下一代的扫描频率降低
以空间换取时间
可变数据类型/不可变数据类型
可变数据类型：修改变量值，内存地址不会变化
不可变数据类型：修改变量值，内存地址会发生改变
两个不可变数据类型的变量值一致，那么他们指向同一个内存地址
核心思想，puthon无法对存于内存中的变量值进行修改，只能减少该变量值的引用计数，从而引发GC机制清除
深/浅复制
深浅复制的核心就是在于：对于容器对象的复制能够复制到容器对象内部嵌套的变量值，而不是内存地址
浅复制：
切片操作就是一个浅复制
.copy()
from copy import copy
copy(iterable)
深复制
from copy import deepcopy
deepcopy(iterable)
输入输出语句
input('xxx')
print(obj,..., sep=' ', end='\n', file=sys.stdout, flush=Flase)
基本运算符
算术运算符
+ - * / ** // % ()
比较运算符
> >= < <= != ==
逻辑运算符
and or not
not > and > or
短路问题：一旦有结果则结束判断
赋值运算符
=
增量赋值
+= -= *= /= //= **= %=
交叉赋值
a,b = b,a
链式赋值
a,b,c,d = 10
解压赋值
a, *b = (1,2,3,4)
成员运算符
in not in
身份运算符
is is not
位运算符
&
|
^
~
>>
<<
流程控制
if...else
if...elif
隐式类型转换
区间判断
三元表达式
i if i > j else j
while True:
while...else
for...in
for...else
break,continue
pass
文件处理
open(file, mode='r', encoding='')
r w a t b + U
read(int) str
readlines(int) list
readline(int) 仅一行
rt：字符数
rb：字节数
write(str/bin)
rt：str
rb：bin
seek(offset, x)
offset：字节
x：0 1 2
tell()
字节
close()
python函数基础
函数的定义与调用
def 函数名():
pass
函数名()
函数的参数
位置参数、默认参数、*args、命名关键字参数、**kwargs
函数的返回值
return
多个返回值使用元组存储
函数的注释
help()
全局变量/局部变量
整个py文件内有效，任意位置皆可调用
局部变量，在函数内部生效，随着函数执行完毕而失效
globals() 字典返回全局变量名
locals() 字典返回局部变量名
名称空间
内建名称空间：随python解释器的启动而产生，关闭而回收，存放python解释器内置的名字
全局名称空间：随py文件的启动而产生，关闭而回收，存放py文件中全局变量的名字
局部名称空间：随函数的调用而产生，执行完毕而回收，存放函数执行中局部变量的名字
作用域：
全局作用域：由内建名称空间和全局名称空间组成，在全局生效，任何位置皆可调用
局部作用域：由局部名称空间构成，仅在函数内部生效，函数调用时存活
global nonlocal
python高阶函数
递归函数
def ceshi():
ceshi()
ceshi()
匿名函数
lambda x,y:print(x,y)
嵌套函数
在函数内部定义一个函数
将一个函数作为参数传递给另外一个函数
将一个函数作为另外一个函数的返回值
闭包函数
def ceshi():
def zzw():
pass
return zzw
__closure__[].cell_contents
获取当前函数使用的局部函数，使用元组存储
装饰器
def xxx(a)
def ceshi(func):
from functools import wraps
@wraps(func)
def zzw():
func()
zzw.__name__ = func.__name__
zzw.__doc__ = func.__doc__
return zzw
return ceshi
@xxx(12)
def jjj():
pass
高阶装饰器
class zzw():
@property
def name(self):
pass
@name.getter
def name(self):
pass
@name.setter
def name(self, *args):
pass
@name.deleter
def name(self):
pass
z = zzw()
z.name --> getter
z.name = value --> setter *args=value
del z.name --> deleter
python内置函数
其他
exit()
hash()
数学相关
abs(number) 绝对值
round(float, x) 限制小数位
pow(a, b) a**b
divmod(a, b) (a//b, a%b)
sum(number) 求和
max(iterable) 最大值
min(iterable) 最小值
hex()
oct()
bin()
int(str, base)
float(number)
complex(number)
数据类型转换
list(iterable)
tuple()
str()
set()
bool()
dict(**kwargs, [(),...])
字符串相关
.format()
bytes()
bytearray()
memoryview().tolist().tobytes()
repr()
ascii()
ord()
chr()
可迭代对象相关(xxx)
all()
any()
iter()
len()
next()
sorted()
zip()
作用域相关
globals()
locals()
输入输出相关
input()
print(obj,..., sep=' ', end='\t', file=sys.stdout, flush=False)
对象继承相关
issubclass(class, (class,...))
isinstance(obj, (class,...))
super(当前obj, self).父类方法名(参数)
返回迭代器(xxx)
range()
map()
filter()
reversed()
字符串类型代码执行
eval('str')
exec()
compile(str, '', 'eval/exec')
针对对象通用
hasattr(obj, '')
getattr(obj, '', default)
setattr(obj, '', new)
delattr(obj, '')
对象修饰符
@staticmethod
@classmethod
常用基本方法
id()
type()
help()
返回一个特殊对象(xxx)
slice()
frozenset()
enumerate()
open()
__import__()
与对象有关的方法(xxx)
dir()
vars()
callable()
object()
property()
python面对对象基础
class 类名(object):
pass
z = 类名
谁调用了self，那么self代指谁
zzw.name = 'lisi'
__开头，无法被继承（_类名__私有）
@staticmethod
def zzw():
pass
@classmethod
def zzw(cls):
cls.name
class zzw():
instance = None
@classmethod
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
继承
类和类之间可以手动建立父子关系，父类的属性和方法，子类可以有条件的使用
class zzw:
pass
class zzw1(zzw,object):
pass
对于多继承，按照 第一个找到死，再找第二个，找到就固定
继承可传递
静态方法或类方法无序重写修饰符
新式类：
继承object的就是新式类
python
经典类：
不继承object的就是经典类
封装
将多行代码（函数和变量）封装成一个类，调用该类就相当于执行这些被封装的代码
多态
多态是一种技巧，可以在继承父类的基础上，对父类的属性和方法进行重新写，从而延申出更多的变化
反射：通过字符串的形式操作对象相关的属性
python模块基础
import
import as
from import *
from import as
from import
默认以当前路径查找，
sys.path
__all__ = []
__name__ = __main__
不管使用何种语句导入模块、或只导入模块中的一个方法，都会会先将整个py文件执行一遍
如果该模块是一个包，那么会将__init__.py文件执行一遍
_开头的属性和方法无法使用from导入，但是可以使用import后 模块名.__ 来调用
'''
浙公网安备 33010602011771号