写在前面
🍁个人主页：HNUJSY
✨推荐专栏：《史上最全经典面试题总结》欢迎订阅学习~
📌Xmind文件获取：GitHub 持续更新中，别忘了 star 喔~
目录
标识符
在 Python 中，所有标识符可以包括**英文（区分大小写的）、数字以及下划线(_)**，但不能以数字开头。
以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
以双下划线开头的 foo 代表类的私有成员，
以双下划线开头和结尾的 __ foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。
语句
Python 的代码块中必须使用相同数目的行首缩进空格数
python中单行注释采用 # 开头。
python 中多行注释使用三个单引号(‘’')或三个双引号(“”")。
# Python语句中一般以新行作为语句的结束符。但是我们可以使用【斜杠（ \）】将一行的语句分为多行显示，# 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割
total = item_one + \
item_two + \
item_three
days =['Monday','Tuesday','Wednesday','Thursday','Friday']# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割。import sys; x ='runoob'; sys.stdout.write(x +'\n')# Python 可以使用【引号( ' )、双引号( " )、三引号( ''' 或 """ ) 】来表示字符串
word ='word'
sentence ="这是一个句子。"
paragraph ="""这是一个段落。
包含了多个语句"""# print 默认输出是换行的，如果要实现【不换行需要在变量末尾加上逗号】 。print x,y
变量
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
Number（数字）
int、float、bool、complex（复数）
内部函数中，strings, tuples, 和 numbers 是不可更改的对象，全局变量必须为init变量或者在函数中用self定义；而 list,dict 等则是可以修改的对象，内部函数可以直接使用函数中的局部变量。
counter =100# 赋值整型变量
miles =1000.0# 浮点型
name ="John"# 字符串
二进制转换：
int('10',2)>2bin(10)>'0b1010'bin(10)[2:]ord(c)# c为字符# 返回值：对应的十进制整数（ASCll数值）int(c)# c为字符，转化为对应的数字float('-inf')# 最小值-inf
a = b = c =1
a, b, c =1,2,"john"all()# 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。# 从左到右索引默认【0开始的】，最大范围是字符串【长度少1】# 从右到左索引默认【-1开始的】，最大范围是【字符串开头】# 第三个参数，参数作用是【截取的步长】
s ="a1a2···an"# n>=0
向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四舍五入：round()——奇数向远离0取整，偶数去尾取整；或言之：奇数进位，偶数去尾
向0取整：int()
List（列表）
tinylist =[123,'john']printlist[0]# 输出列表的第一个元素printlist[1:3]# 输出第二个至第三个元素 printlist[2:]# 输出从第三个开始至列表末尾的所有元素# 二维数组
num_list =[[0]*5for i inrange(2)]
dp =[[1]*n]+[[1]+[0]*(n-1)for _ inrange(m-1)]
clone_node.neighbors =[self.cloneGraph(n)for n in node.neighbors]# 加号 + 是列表连接运算符，星号 * 是重复操作print tinylist *2# 输出列表两次printlist+ tinylist # 打印组合的列表list.append('Google')# 使用 append() 添加元素dellist[2]# 可以使用 del 语句来删除列表的元素list.pop(3)# 指定pop参数，将会删除该位置的元素；无参数时默认删除最后一个元素list.append(sublist)# 引用传递list.append([]+sublist)# 值传递list.append(list(path))len([1,2,3])3#长度[1,2,3]+[4,5,6][1,2,3,4,5,6]#组合['Hi!']*4['Hi!','Hi!','Hi!','Hi!']#重复3in[1,2,3]True#元素是否存在于列表中for x in[1,2,3]:print x,123#迭代[::-1]# 数组反转max(list)# 求list的最大值sum(sp[i]for i inrange(n))#求和sum(s in jewelsSet for s in stones)
nums.sort()# 排序
score.sort(reverse=True)list有一个sort方法，list.sort()将list进行排序，返回None
sort(*,key =None,reverse =False)
key是一个函数，这个函数的作用是从list的每个元素中提取用于当作排序依据的属性
默认是从小到大，即reserve为False的时候，如果reserve为True，排列顺序就是从大到小
deff(item):return item[1]list.sort(key = f)list.sort(key =lambda item:item[0])sorted(iterable,*,key=None,reverse=False)# 默认正序排列sorted(dict.items(),key=lambda item:item[0])
res =sorted(hash,key =lambda word:(-hash[word],word))# 第一个参数 -hash[word] 即单词出现次数的相反数# 当词频相同时，用第二个参数 word 进行排序，即字母正序排列
列表解析 List Comprehensions
表达式：[expression for iter_val in iterable if cond_expr][expression]：最后执行的结果
[for iter_val in iterable]：这个可以是一个多层循环
[if cond_expr]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。
print[(x,y)for x in[1,2]for y in[3,4]]for(k1, v1),(k2, v2)inzip(dict_one, dict_two):# 遍历两个list或者dictfor item in product([1,2],[10,20]):# 对矩阵做笛卡尔积print(item)for i, j in product(range(m),range(n)):
neighbors =[(1,0),(1,-1),(0,-1),(-1,-1),(-1,0),(-1,1),(0,1),(1,1)]for neighbor in neighbors:
r =(row + neighbor[0])
c =(col + neighbor[1])for u,v in neighbors:
s =[1,2,3,4,5]# 从指定索引1开始for index, value inenumerate(s,1):list(str(n))# int转化为字符串，转化为listnext(word for word,f in freq.items()if f==maxFreq)# next()取list第一个值map(max, grid)# 求每行的最大值map(max,zip(*grid))# 求每列的最大值
strs =map(str,nums)# 转换为list(str)
r1,m1 =map(int, num1[:-1].split('+'))# list(str)转化为list(int)list(map(list,numSet))>>> a =[1,2,3]>>> b =[4,5,6]>>> c =[4,5,6,7,8]>>> zipped =zip(a,b)# 返回一个对象>>> zipped
<zipobject at 0x103abc288>>>>list(zipped)# list() 转换为列表[(1,4),(2,5),(3,6)]>>>list(zip(a,c))# 元素个数与最短的列表一致[(1,4),(2,5),(3,6)]>>> a1, a2 =zip(*zip(a,b))# 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式>>>list(a1)[1,2,3]>>>list(a2)[4,5,6]
tuple(元组)
# 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
tinytuple =(123,'john')
Dict(字典)
# 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。dict={}dict['one']="This is one"dict[2]="This is two"# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或 元组 。 用列表就不行dict[tuple(count)]# 以列表返回字典中的所有值dict.values()list(dict.values())for key indict:print(key)
tinydict ={'name':'runoob','code':6734,'dept':'sales'}printdict['one']# 输出键为'one' 的值printdict[2]# 输出键为 2 的值print tinydict # 输出完整的字典print tinydict.keys()# 输出所有键print tinydict.values()# 输出所有值
maxFreq =max(freq.values())# 求value的最大值
tinydict['Age']=8# 更新
tinydict['School']="RUNOOB"# 添加del tinydict['Name']# 删除键是'Name'的条目
tinydict.clear()# 清空字典所有条目del tinydict # 删除字典
defaultdict(list) defaultdict(int)# defaultdict类的初始化函数接受一个类型作为参数，当所访问的键不存在的时候，可以实例化一个值作为默认值：
count.get(c,0)# 默认值为0
items():返回所有（key，value）元组的数组,类似于‘列表’
[s for s, c in cnt.items()if c == maxCnt]# 遍历dictdict排序
sorted(dict.items(),key=lambda item:item[0])
items =[(-val, key)for key, val in count.items()]# 变更为tuplefor val, key insorted(items):# 遍历排序后的tuple
set(集合)
parame ={value01,value02,...}
或者
set(value)
s.add( x )
s.update( x )# 参数可以是列表，元组，字典等
s.remove( x )
s.discard( x )len(s)
s.clear()
x in s
for key inset:print(key)
运算符
/ 除 - x除以y
% 取模 - 返回除法的余数
****** 幂 - 返回x的y次幂
// 取整除 - 返回商的整数部分（向下取整）
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
not not x 布尔"非" - 如果 x 为 True，返回 False 。
is is 是判断两个标识符是不是引用自一个对象
is not is not 是判断两个标识符是不是引用自不同对象
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
条件语句
if num ==3:# 判断num的值print'boss'elif num ==2:print'user'elif num ==1:print'worker'elif num <0:# 值小于零时输出print'error'else:print'roadman'# 条件均不成立时输出
循环语句
i =1while i <10:
i +=1if i%2>0:# 非双数时跳过输出continueprint i # 输出双数2、4、6、8、10
i =1while1:# 循环条件为1必定成立print i # 输出1~10
i +=1if i >10:# 当i大于10时跳出循环break
flag =1while(flag):print'Given flag is really true!'
fruits =['banana','apple','mango']for fruit in fruits:# 第二个实例print('当前水果: %s'% fruit)
fruits =['banana','apple','mango']for index inrange(len(fruits)):print('当前水果 : %s'% fruits[index])for i inreversed(range(length -1)):# 逆序for letter in'Python':# 第一个实例if letter =='h':breakprint'当前字母 :', letter
for i, ch inenumerate(s):if frequency[ch]==1:return i
diff =[(a,b)for a,b inzip(s,goal)if a!=b]
字符串
+ 字符串连接
>>>a + b
'HelloPython'* 重复输出字符串
>>>a *2'HelloHello'[] 通过索引获取字符串中字符
>>>a[1]'e'[:] 截取字符串中的一部分
>>>a[1:4]'ell'in 成员运算符 - 如果字符串中包含给定的字符返回 True>>>"H"in a
Truenotin 成员运算符 - 如果字符串中不包含给定的字符返回 True>>>"M"notin a
True
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
>>>printr'\n'
\n
>>>printR'\n'
\n
strs ='abcd'for ch in strs:print(ch)
strs ='abcd'for index inrange(len(strs)):print(strs[index], end=' ')
res +='a'*3# 'aaa'
s.split(" ")# 将字符串分割成单词列表" ".join(list)# 将单词列表转换为字符串，以空格分隔f'{bulls}A{cows}B'# {}计算格式化
a =list(str(n))# int转成list
a[i-1]=str(int(a[i-1])-1)# 操作字符int("".join(a))# list转化为int
isdigit # 函数判断是否数字
isalpha # 判断是否字母
字符串格式化
print"My name is %s and weight is %d kg!"%('Zara',21)%s 格式化字符串
%d 格式化整数
%f 格式化浮点数字，可指定小数点后的精度
三引号
允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
>>> hi ='''hi
there'''>>> hi # repr()'hi\nthere'>>>print hi # str()
hi
there
函数
string.count(str, beg=0, end=len(string))# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.endswith(obj, beg=0, end=len(string))# 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.find(str, beg=0, end=len(string))# 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()# 格式化字符串
string.index(str, beg=0, end=len(string))# 跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.join(seq)# 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.replace(str1, str2, num=string.count(str1))# 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.split(str="", num=string.count(str))# 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
函数
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
在Python中，数字、字符或者元组等不可变对象类型都属于值传递，而字典dict或者列表list等可变对象类型属于引用传递。
如果要想修改新赋值后原对象不变，则需要用到python的copy模块，即对象拷贝。
copy.copy属于浅拷贝，拷贝的是第一层list，而copy.deepcopy属于深拷贝，对list所有子元素都进行深拷贝。
#可写函数说明defprintinfo( name, age =35):"打印任何传入的字符串"print"Name: ", name
print"Age ", age
return#调用printinfo函数
printinfo( age=50, name="miki")
printinfo( name="miki")# 可写函数说明defprintinfo( arg1,*vartuple ):"打印任何传入的参数"print"输出: "print arg1
for var in vartuple:print var
return# 调用printinfo 函数
printinfo(10)
printinfo(70,60,50)import copy
l1 =[[1,2],3]
l2 = copy.copy(l1)
l3 = copy.deepcopy(l1)
l2.append(4)
l2[0].append(5)
l3[0].append(6)
l1 =[[1,2,5],3]
l2 =[[1,2,5],3,4]
l3 =[[1,2,6],3]
匿名函数
# 可写函数说明sum=lambda arg1, arg2: arg1 + arg2
# 调用sum函数print"相加后的值为 : ",sum(10,20)print"相加后的值为 : ",sum(20,20)
模块
import support
from fib import fibonacci
from math import*
搜索路径
1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。 init.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、 init.py 文件，test.py 为测试调用包的代码，目录结构如下:
test.py
package_runoob
|-- init.py
|-- runoob1.py
|-- runoob2.py
# 导入 Phone 包from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2
runoob1()
runoob2()
文件
str=input("请输入：")print"你输入的内容是: ",str
fo =open("foo.txt","w")print"文件名: ", fo.name
print"是否已关闭 : ", fo.closed
print"访问模式 : ", fo.mode
print"末尾是否强制加空格 : ", fo.softspace
# 打开一个文件
fo =open("foo.txt","w")str= fo.read(10)
fo.write("www.runoob.com!\nVery good site!\n")# 关闭打开的文件
fo.close()
文件和文件夹
import os
os.rename("test1.txt","test2.txt")
os.remove("test2.txt")
os.mkdir("test")# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")# 给出当前的目录print os.getcwd()# 删除”/tmp/test”目录
os.rmdir("/tmp/test")
异常
try:
正常的操作
......................except:
发生异常，执行这块代码
......................else:
如果没有异常执行这块代码
try:
fh =open("testfile","w")
fh.write("这是一个测试文件，用于测试异常!!")except IOError:print"Error: 没有找到文件或读取文件失败"else:print"内容写入文件成功"
fh.close()try-finally 语句无论是否发生异常都将执行最后的代码。
try:<语句>finally:<语句>#退出try时总会执行raisetry:
fh =open("testfile","w")try:
fh.write("这是一个测试文件，用于测试异常!!")finally:print"关闭文件"
fh.close()except IOError:print"Error: 没有找到文件或读取文件失败"
面向对象
classEmployee:'所有员工的基类'
empCount =0def__init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount +=1defdisplayCount(self):print"Total Employee %d"% Employee.empCount
defdisplayEmployee(self):print"Name : ", self.name,", Salary: ", self.salary
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara",2000)"创建 Employee 类的第二个对象"
emp2 = Employee("Manni",5000)
emp1.displayEmployee()
emp2.displayEmployee()print"Total Employee %d"% Employee.empCount
empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
继承
classA:# 定义类 A.....classB:# 定义类 B.....classC(A, B):# 继承类 A 和 B.....
重写
classParent:# 定义父类defmyMethod(self):print'调用父类方法'classChild(Parent):# 定义子类defmyMethod(self):print'调用子类方法'
运算符重载
classParent:# 定义父类defmyMethod(self):print'调用父类方法'classChild(Parent):# 定义子类defmyMethod(self):print'调用子类方法'
类属性和方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods
单下划线、双下划线、头尾双下划线说明：
foo: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
版权归原作者 HNUJSY 所有， 如有侵权，请联系我们删除。