print()
print 参数：end 默认为 换行，即end = "\n"
能够不换行，即 end = ""
或指定结束，即 end = "abc"
#内建函数
"""
注释
"""
%d 整数javascript
%f 浮点型 %0.1f 保留一位css
%s 字符串html
import copy #引入copy包裹
import random #引入random包裹
import functools #引入functools包裹，不经常使用的函数
import time
import os 系统 os.system("cls")
import os.path
import pickle
import csv
from urllib.request import *
import re
import tkinter as tk
os.system() 命令行控制台java
os.listdir() 显示目录下的内容python
os.mkdir() 建立文件夹git
os.path.isfile() 是否为文件编程
os.path.isdir() 是否为路径canvas
print（）api
input（）数组
type（）
name = input("名字")
print(name,":",type(name))
名字123
123 : <class 'str'>
float（）
int（）
bin（）
hex（）
oct（）
id（）查看变量的地址
range(start,end,step) 建立序列 start 开始， end 结束， step 步进值
ord('A') 转化单个字母
chr(97) 'a' 转化为字符串
name='张三'
name.encode('utf8')
int.from_bytes(name.encode('utf8'),xxxx='big')
变量不须要先声明，直接赋值，直接使用
同时给多个变量赋值
命名：数字字母下划线组成，不能以数字开头，区分大小写，不能使用$
不支持 自增自减 a += 1;
变量名不能够是 关键字和保留字
整数
0b开头，二进制；0o开头，八进制；0x，十六进制；科学计数法，8e2 = 800
浮点数
复数：虚部以 j 或 J 结尾的为复数
单引号
双引号
三引号：1.多行注释；2. 实现 多行输出
转义字符：\
#1.前缀 r
print(r"\n\r\t")
#输出 \n\r\t
#2.前缀 b
#表明后面的字符串是byte数据。在python2中 print函数操做的字符串所有为byte型数据
# python3中 是Unicode数据
#3.前缀 u
#表明后面的字符串是Unicode数据。python2为了兼容python3
【**】切片
str1 = "山西优逸客"
print（str1[开始下标：结束下标：步进值]）
默认 0 ： 最后 ：1
print（str1[：：-1]）
arr = ["1","2","3","a","b"] #必须为字符串才能用 join
",".join(arr)
#输出结果：1，2，3，a，b
str1 = "1,2,3,4,5,6"
str1.split(",") # ["1","2","3","4","5","6"]
str1.split(",",2) # ["1","2","3,4,5,6"]
str2 = " 13 "
print(len(str2))
str3 = str2.strip()
print(len(str3))
str4 = str3.strip("1")
print(len(str4))
str1 = "1_2_3,4,5\n6"
print(str1.splitlines())
#输出结果
9
2
1
['1_2_3,4,5', '6']
列表语法：mylist=[1,2,3,4]
注意：
列表能够保存任意类型数据
列表可使用切片
列表是可变的，字符串不可变
能够建立空列表，也能够建立只有一个元素的列表
能够建立多维列表
列表的遍历 for item in arr:
for item in mylist:
print(mylist.index(item),end=" ")
print(item)
#
for i,v in enumerate(mylist):
print(i)
print(v)
#enumerate(mylist)：将列表转化为（index,item）序列
深拷贝与浅拷贝
import copy #引入copy包裹
copy.copy(arr) #浅拷贝 里面变化
copy.deepcopy(arr) #深拷贝 一直不变
列表内建函数
List.append() 在最后插入一个元素
List.insert(10,"a") 在任意位置插入元素
List.extend([4,5,6]) 合并两个 list 数据
print(arr + [4,5,6] + [7,8,9]) #合并多个
List.count(item) 查看某元素在list的次数k
List.index(item) 查看item在list中的第一个下标。没有 则 报异常
List.pop() 删除最后一个元素
List.remove(item) 删除列表中的元素，有相同的删除第一个
List.reverse() 将list反转
List.sort(reverse=True) 排序 默认为升序 reverse=True 降序
List.copy() 浅拷贝
List.clear() 清空数组
推倒式（python 特有的写法 语法糖）
arr1=['1','2','3','4']
arr2=[item for item in arr1 if item=='3'] #
print(arr2) # ['3']
mytuple=(1,) 定义一个加，
能够定义空元组 不能够改变
mytuple=([],[]) 能够改变 可使用数组的一些方法
注意：
元组元素不可改变
经过圆括号定义
可使用切片
定义一个元素的元组，逗号不可少
空元组
len(list)数组的长度
max()数组的最大数
min()数组的最小数
list()将元组转换为列表
tuple()将列表转换为元组
enumerate()返回下标和元素
建立方式
1.json格式建立
a = {"name":"小白"}
2.经过内建函数
b = dict(name="小红"，age=10)
3.经过映射函数的方式
c = dict(zip(["name","age"],["小红"，"10"])) #映射函数
4.可迭代对象的方式
d = dict([("name","小红")，("age",10)])
如何批量建立：
mydict = dict.fromkeys(["name1","name2"],"小白")
print(mydict)
#输出结果
#{'name1': '小白', 'name2': '小白'}
字典的访问：mydict[键]
删除：del mydict[键]
mydict.clear () 清空
mydict.keys () 键名
mydict.values () 值
mydict.items () 键名：值
mydict.setdefault ("键名"，值) 添加
mydict.pop() 删除
mydict.popitem() 删除最后一位的key:value
mydict.get("key","info") 存在key，返回key对应的value。不存在key，返回信息 info
float（） 转化为浮点型
int（） 转化为整型
bin（）将十进制转化为 二进制
oct（）将十进制转化为 八进制
hex（）将十进制转化为 十六进制
惟一的、不可变的
建立：
myset = set([1,2,3])
myset = set("abc")
添加：
myset.add("de") #{"a","b","c","de"}
myset.update("de") #{"a","b","c","d","e"}
删除：
myset.remove("d")
列表去重
list1 = [1,2,3,4,4,5]
list2 = list(set(list1));
差集（-）、交集（&）、并集（|）
算数运算符：
基本算数运算符：+ - * /
// 除 结果为 int
% 取余
** 幂运算
逻辑运算符
and 与
or 或
not 非
关系运算符：
#js 动态类型 弱类型的语言（隐式转换）
#python 动态类型 强类型的语言（不会转化类型）
== 等于
!=不等于
“> 大于
< 小于
">= 大于等于
<= 小于等于
位运算符：
&：按位与，两个位 数都为1，按位与结果为1.不然为0；
|：按位或，两个位 数只要有一个为1，按位或结果为1.不然为0；
^：按位异或，两个对应的二进位相异时，结果为 1 。相同为 0；
~：按位取反，0为1，1为0；
<< n：左移n位
''>> n：右移n位
赋值运算符：
=
+=
-=
*=
/=
%=
//=
**=
成员运算符：
in
arr = [1,2,3]
print(i in arr) #True
not in
身份运算符：
is 判断id地址是否同样，即 为同一个
num1 = 123;
num2 = 123;
print(num1 is num2) #True
is not
幂运算、正负、算数运算符、关系运算符、赋值运算符、身份运算符、成员运算符、逻辑运算符
** 指数 (最高优先级) ~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) */ % // 乘，除，取模和取整除 + - 加法减法 >> << 右移，左移运算符 & 位 'AND' ^ | 位运算符 <= < > >= 比较运算符 <> == != 等于运算符 = %= /= //= -= += *= **= 赋值运算符 is is not 身份运算符 in not in 成员运算符 not and or 逻辑运算符
if 1>2:
print("1>2")
elif 2==1:
print("2=1")
else:
print("1<2")
结果1 if 表达式 else 结果2
print(1 if 1>2 else 2) #输出结果：2
for
for i in range([start,] end [,step]):
print(i)
for i in range(1,10):
str1 = ""
for j in range(1,i+1):
if (j==2 and i==3)or(j==2 and i==4):
str2 = " "
else:
str2 = " "
str1 += str(j) + "*" + str(i) + "=" + str((i*j)) +str2
print(str1)
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(j,i,i*j),end=" ")
print("")
while
import random
num = random.randint(0,100)
s = 0
while True:
if s<5:
num1 = int(input("请输入0-100的数字："))
s += 1
if num1 > num:
print("大了一点")
elif num1 < num:
print("小了一点")
else:
print("恭喜你！")
break
else:
print("你输了！")
break
continue：
break：
定义：def
def add(a,b):
print(a,b) # 30,20
return a+b
print(add(b=20,a=30)) # 50
默认参数：
def add(a=10,b):
print(a,b)
return a+b
print(add(b=20))
可变参数：*arr
def aa(*arr):
print(arr)
aa(1,2,3,4,5)
# 输出结果 （1，2，3，4，5）元组
关键字参数：**attr
def person(name,age=20,**attr):
print("name:%s"%name)
print("age:%s"%age)
print(attr)
person(name="xb",age=18,sex="男",tel=123456) #name:xb age:18 {'sex':'男'，'tel':123456}
person(name="xb", sex="男", tel=123456) #name:xb age:20 {'sex':'男'，'tel':123456}
person("xb", sex="男", tel=123456) #name:xb age:20 {'sex':'男'，'tel':123456}
参数的定义顺序：必选参数、默认参数、可变参数、关键字参数
def person(name, age=20,*cj, **attr):
print("name:%s" % name)
print("age:%s" % age)
print(cj)
print(attr)
person("xb",68,78,84,92, sex="男", tel=123456)
#输出结果：
name:xb
age:68
(78, 84, 92)
{'sex': '男', 'tel': 123456}
yield #将函数的返回内容 装进生成器对象里面
# 求指定数字个数的斐波那契数列
def math4(num1):
p=0
q=1
c=0
while c<num1:
yield q
p,q=q,p+q
c+=1
print(list(math4(20)))
实参高阶函数： 看成形参传入
返回值高阶函数： 返回值为一个函数
def add(a,b):
return a+b
def sub(a,b):
return a-b
def size(a,b,fn):
return fn(a,b)
print(size(10,20,add)) #实参高阶函数 30
print(size(10,20,sub)) #实参高阶函数 -10
#返回值高阶函数
def fn():
def aa():
print("这是一个函数")
return aa
bb = fn()
bb()
def fn():
pass
lambda 参数 : 函数体（一行）
1.能够有多个参数
2.不须要 return，自动return
调用：
1.自调用
print( (lambda a,b:a+b)(10,20) ) #30
2.字面量
fn = lambda a,b:a+b
print( fn(10,20) ) #30
经常使用的使用场合：map、reduce、filter
arr = map(lambda x:x*2,range(1,11))
print(list(arr))
#[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
arr = map(lambda x,y:x+y,range(1,11),range(0,10))
print(list(arr))
#[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
arr1 = map(lambda x,y:x+y,range(1,11),range(0,5))
print(list(arr1))
#[1, 3, 5, 7, 9]
arr = filter(lambda x:x>5,range(1,11))
print(list(arr))
#[6, 7, 8, 9, 10]
import functools
num = functools.reduce(lambda x,y:x+y,range(1,11))
# x:0 y:1
# x:1 y:2
# x:3 y:3
# x:6 y:4
print(num)
注意：全局变量 在局部，只能访问，不能 修改
关键字：global aa #aa 为想要改变的全局变量
至关于 声明。不能直接 赋值 进行改变
aa = 123
def fn1():
global aa,bb
aa = 456
bb = 50
fn1()
print(aa,bb) # 456
1. 改变全局变量 eg:aa
2. 声明全局变量 eg:bb
关键字：nonlocal aa
num1 = 123
def fn1():
num1 = 456
def fn2():
nonlocal num1
num1 += 10
fn2()
print(num1)
fn1() # 466
在函数中 能够定义另外一个函数时，若是内部函数引用了外部函数的变量，而且调用内部函数，则 产生闭包
做用：
1.在一个函数与一组私有变量之间建立关联关系； 2.在给定函数被屡次调用的过程当中，这些私有变量保持持久性。
def aa():
num1 = 456
def bb():
print(num1) # 做用2
return bb
b = aa()
b() # 456 # 做用1
def f(num):
if num==1:
return 1
else:
return f(num - 1)*num
print(f(5))
为了给某程序增添功能
**理解：把须要改变的函数 看成 参数 传入新的函数中，让新的函数完成添加的功能。
最后 让 原函数名 等于 新函数 的返回值【返回值为一个函数】
三个原则：
不能修改被装饰的函数的源代码
不能修改被装饰的函数调用
知足一、2的状况下给函数添加新功能
装饰器定义公式：
import time
# 装饰器，添加新功能
def tester(fn):
def newtest():
start = time.time() #记录时间的函数
fn() #不修改被装饰的函数调用
end = time.time()
print("总时间：",end-start)
return newtest
# 源程序
def test():
time.sleep(1) #程序休眠 1 秒
print("test is running")
test = tester(test) # 源程序为“装饰”以后的。名字能够任意
test()
import time
# 装饰器，添加新功能
def tester(fn):
def newtest():
start = time.time() #记录时间的函数
fn() #不修改被装饰的函数调用
end = time.time()
print("总时间：",end-start)
return newtest
按照需求往外加函数
实质：从里到外 调用
import time
装饰器，添加新功能
def tester1(a,b)
def tester(fn):
def newtest():
start = time.time() #记录时间的函数
fn() #不修改被装饰的函数调用
end = time.time()
print("总时间：",end-start)
print("参数："，a,b)
return newtest
retuen tester
open(文件路径,打开文件模式,encoding = "utf-8",errors = "ignore")
#1.读操做
f = open("note.txt","r") #文件的对象
con1 = f.read([num]) #num表明读取字符数量,默认为所有
con2 = f.readline([num]) #文件读取每一行,经过\r \n EOF（文件结束标识）。num表明读取一行的几个字符
con3 = f.readlines() #返回列表形式
f.close()
print(con) # 山西太原
#2.写操做
f = open("note.txt","w")
f.write(str) 把str写入文件,不会在str后加入换行符
f.writelines(arr) 把arr写入
打开文件模式：
r 读操做（默认） rb 以二进制的方式读取
w 写操做 每次执行重头开始写入，路径不对会建立新文件 【由于 打开 指针指向开始】
a 追加 每次执行直接添加，路径不对会建立新文件【由于 打开 指针指向结尾】
r+ 读写，不建立新文件，每次读写在文件开头
w+ 读写，建立新文件，每次读写会覆盖文件内容
a+ 读写，建立新文件，每次读写追加
f.seek():移动 文件读取指针到指定位置
f.seek(p,0) 开始，移动到文件第p个字节处，绝对位置
f.seek(p,1) 当前位置，移动到相对于当前位置以后的p个字节（文件以二进制方式打开）
f.seek(p,2) 结尾，移动到相对文章尾以后的p个字节（文件以二进制方式打开）
【p为偏移量】
f.tell():返回文件读取指针位置
f.flush():把缓冲区的内容写入硬盘
f.close():1.把缓存区的内容写入硬盘；2.关闭文件
try:
f = open("note2.txt","r") #捕获异常。
except: #发生异常时执行；
print("发生错误")
try:
f = open("note2.txt","r") #捕获异常。
finally: #不管发不发生异常都执行；
if f: #若是f文件存在
f.close() #关闭文件
with open("note2.txt","r") as f: #用完自动关闭文件
f.read()
pickle.dump(obj,f)
obj = pickle.load(f)
import pickle
# obj = [{"name":"小白","sex":"男","age":20}]
# with open("note.txt","wb") as f:
# pickle.dump(obj,f)
with open("note.txt","rb") as f:
obj = pickle.load(f)
print(obj[0])
import csv
with open("demo.csv","w"[,newline=""]) as f:
writer = csv.writer(f,dialect="excel")
for i in range(10):
writer.writerow([1,2,3,4,5])
with open("demo.csv","w"[,newline=""]) as f:
writer = csv.writer(f,dialect="excel")
writer.writerows([[1,2,3,4,5],[6,7,8]]) #建立多行
writer1 = csv.DictWriter(f,["id","name","sex","tel"])
writer1.writerheader()
with open("demo.csv","r") as f:
reader = csv.reader(f)
print(list(reader))
#
[['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], []]
with open("demo.csv","r") as f:
reader = csv.DictReader(f)
for item in list(reader):
print(dict(item))
#
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5':