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':