代碼 append() 單位 shuff 資料 now() 查找 lse 嚴格

整數

二進制

n1 = 0b1010

八進制

n2 = 0o567

十六進制

n3 = 0xfdc2
浮點數

一般形式

n1 = 3.14

科學計數法

n2, n3 = 3.2e6, 1.2e-3
簡單數學函數

內建函數

abs(num):

返回數的絕對值

n1, n2, n3 = 1, 0, -1
print(abs(n1), abs(n2), abs(n3)) # 1 0 1
max(num) 和 min(num):

參數不定長

n1, n2, n3, n4 = 1, 2, 3, 4
print(max(n1, n2), min(n2, n3 , n4)) # 2 4

接收可叠代對象

li = [1, 2, 3, 4]

print(max(li)) # 4
round(num, n]):

四舍五入

n表示四舍五入的小數位數，不寫默認是0(取整)

pi = 3.14159
print(round(pi)) # 3
print(round(pi, 3)) #3.142
math模塊中的函數

ceil():

用來向上取整

import math
pi = 3.14159
print(round(pi)) # 3
print(math.ceil(pi)) # 4
print(round(pi + 0.5)) # 可以替代ceil()
floor():

用來向下取整

import math
x = 3.678
print(round(x)) # 4

print(math.floor(x)) # 3
print(floor(x - 0.5)) # 可以替代floor()
sqrt():

平方根運算

import math
print(math.sqrt(16)) # 4
print(math.sqrt(17)) # 4.123105635
隨機函數

random():
import random
print(random.random()) # 生成[0, 1)的一個小數
choice(seq):
import random
li = [1, 2, 4, 5]
print(random.choice(li)) # 從對應的列表中隨機選擇一個元素
uniform(x, y):

import random
print(random.uniform(1, 3) # 得到[1, 3]之間的隨機小數
randint(x, y):
import random
print(random.randint(1, 5)) # [1, 5]之間的隨機整數
randrange(start, stop, step):
import random
print(random.randrange(2, 10, 2) # 參數類型與range()函數一樣

相當於random.choice([2, 4, 6, 8])

三角函數

import math
angle = 1 / 6 * math.pi # 30°, pi/6
res1 = math.sin(angle) # 接收弧度值
angle = math.radians(30) # 將角度值轉換為弧度值
res1 = math.cos(angle)
布爾類型

是 int 的子類型，計算時會自動轉換為 int

True = 1, False = 0

可以與整數進行運算

print(2 + True) # 3
print(1 + False) # 1
是一種單獨的類型

flag, tag = True, False
可以當作判定條件使用

if True:

todo

字符串

字符串表示方式

str = ‘abc‘ # 單引號對
str = "abc" # 雙引號對
str = ‘‘‘abc‘‘‘ # 三個單引號
str = """abc""" # 三個雙引號

混合表示，去掉字符串兩端的限制符號就得到字符串數據

可以避免使用引號的轉義來表示引號

str = "his name is ‘rity‘, that is a good name"

使用轉義字符來完成

str = "his name is ‘rity‘, that is a good name"

消除字符串的轉義

str1 = "That‘s all"
str2 = r"That‘s all"
print(str1) # That‘s all
print(str2) # That‘s all

字符串的跨行表示

str = "his name is ‘rity‘, "
"that is a good name"
str = ("his name is ‘rity‘, "
"that is a good name")

"""
可以直接在三對雙引號內進行換行
多用於程序段的註釋
---end---
"""
字符串的操作

一般操作
字符串拼接
res1 = "abc" + "def"
print(res1) # abcdef
res2 = "abc" "def"
print(res2) # abcdef
res3 = "%s%S" % ("abc", "def")
print(res3) # abcdef
字符串的乘法
res = "a" * 3
print(res) # aaa
字符串的切片
str = "abcdefg"

獲得單個字符

print(str[3]) # d
print(str[-1]) # g

獲得字符串片段

str[start:end:step]

默認值：start=0, end=len(str), step=1

獲得範圍 [start, end)

print(str[::]) # abcdefg
print(str[0:len(str):1]) # agcdefg
print(str[::2]) #aceg
print(str[::-1]) #gfedcba
函數操作
len():

可用於所有可叠代對象

計算字符串中字符的個數

name1， name2 = "rity", "瑞迪"
print(len(name1), len(name2)) # 4 2
find():

查找子串的索引

find(substr, start, end)

默認值：start=0, end=len(str)

str = "abcdabefg"
print(str.find("ab")) # 0
print(str.find("ab", 1)) # 4
print(str.find("xy")) # -1
count():

計算子字符串出現的個數

count(sub, start, end)

默認值：start=0, end=len(str)

str = "abcda"
print(str.count("a")) # 2
print(str.count("a", 2) # 1
print(str.count("x")) # 0
replace():

用給定的新字符串替換舊的字符串

replace(old, new, count)

默認值：count(省略)，全部替換

str = "abacad"
print(str.replace("a", "A")) #AbAcAd
print(str.replace("a", "A", 2)) #AbAcad
print(str) # abacad
ljust() 和 rjust():

對字符串進行長度調整(擴長)

ljust(width, fillchar)

width:要擴展到的長度，fillchar:填充的字符

str = "abc"
print(str.ljust(6, "x")) # abcxxx
print(str.rjust(6, "x")) # xxxabc
print(str) # abc
lstrip() 和 rstrip() 和 strip()

移除字符串指定位置的字符

lstrip(str)

默認值：str是空字符集

name = "xi am rity ."
print(name.lstrip("ix")) # | am rity .|
print(name.rstrip(". ") # |xi am rity|
print(name.strip("ix.")) # | am rity |
split():

將父字符串分割成幾個子字符串

split(sep=None, maxsplit=-1)

sep:要分割的字符，maxsplit：最大分割次數

默認值：maxsplit(省略)，全部分解

返回字符串列表

info = "rity,nanchang,158-7926-7420"
res = info.split(",")
print(res) # [‘rity‘, ‘nanchang‘, ‘158-7926-7420‘]

多個分隔符連續的一種情況

num = "12 3 4"
res = num.split(" ")
print(res) # [‘12‘, ‘‘, ‘3‘, ‘4‘]

省略分隔符的一種情況

str = "a c b "
res = str.split()
print(res) # [‘a‘, ‘c‘, ‘b‘] 省略首尾的空白字符，將中間連續的空白字符視作一個分隔符進行分隔
partition():

把整個字符串分三部分

partition(sep)

從左往右找

返回一個元組(分隔符左側， 分隔符， 分隔符右側)

pi = 3.14159
res1 = pi.partition(".")
res2 = pi.partition("-")
print(res1) # (‘3‘, ‘.‘, ‘14159‘)
print(res2) # (‘3.14159‘, ‘‘, ‘‘)
join():

用指定的字符串，對可叠代參數進行拼接，返回字符串

"xx".join(iterable)

與split()的作用相反

li = ["137", "9878", "0098"]
res1 = "-".join(li)
res2 = "".join(li)
print(res1) # 137-9878-0098
print(res2) # 13798780098
isalpha(), isdigit(), isalnum()
str1, str2, str3, str4, str5 = "agcD", "123", "2j3e4ef", ""
print(str1.isalpha()) # True
print(str2.isdigit()) # True
print(str4.isalnum()) # True
print(str5.isalpha(), str5.isdigit(), str5.isalnum()) # False False False
startswith() 和 endswith()

是否以某個前綴開頭/結尾,範圍 [start, end)

startswith("xx", start, end)

默認值：start=0, end=len(str)

name = "2018-08-09: xxx報告"
file = "xxx.md"
print(name.startswith("2018")) # True
print(file.endswith(".md")) # True
列表

有序可變元素的集合

表示方式

元素類型單一

li = ["a", "b", "c"]

多種類型的元素

li = ["a", "b", 1, 2, True]

列表可以相互嵌套

li = [[1, 2, 3], 2, True, "hehe"]

list()函數，參數為可叠代對象

li = list(range(1, 4)) # [1, 2, 3]
li = list("abc") # (‘a‘, ‘b‘, ‘c‘)

列表推導

nums = [1, 2, 3, 4, 5]
li = [n*n for n in nums if n % 2]
print(li) # [1, 9, 25]
常用操作

append():

向列表的尾部添加元素

nums = [1, 2, 3, 4]
nums.append(5)
print(nums) # [1, 2, 3, 4, 5]
insert:

向列表中的任意位置插入元素

nums = [1, 2, 3, 4]
nums.insert(1, 9)
print(nums) # [1, 9, 2, 3, 4]
extend():

合並兩個列表

nums1, nums2 = [1, 2], [3, 4]
nums1.extend(nums2)
print(nums1) # [1, 2, 3, 4]
del語句:
nums = [1, 2, 3]
del nums[0]
print(nums) # [2, 3]

del用來刪除所引用的對象

pop():

移除並返回列表中指定索引的元素

pop(index)

默認值：index(不寫)，刪除返回最後一個

nums = [1, 2, 3]
res = nums.pop()
print(nums, res) # [1, 2] 3
remove():

移除列表中指定的元素

remove(obj)

若元素不存在會報錯，若有多個元素，刪除最左邊的那個

names = ["Rity", "Jack", "Tom"]
names.remove("Jack")
print(names) # ["Rity", "Tom"]

遍歷刪除元素會出現錯誤

元素刪除後影響了列表的結構，進而影響了遍歷的過程

nums = [1, 2, 2, 3, 4, 2]
for n in nums:
if n == 2:
nums.remove(n)
print(nums) # [1, 3, 4, 2]
index():

獲得元素所在的索引值,查找範圍：[start, end)

index(obj, start, end)

默認值：start=0, end=len(list)

li = [12, 34, 99]
idx = li.index(34)
print(idx) # 1
count():

獲得其中某個元素的個數

li = [1, 1, 2, 3, 5]
print(li.count(1)) # 2
切片：參考字符串切片
列表遍歷：

索引問題

val = ["a", "b", "a", "d"]
currentIdx = 0 # 解決index("a")恒為0的問題
for v in val:
idx = val.index(v, currentIdx)
print(idx, v)
currentIdx += 1

建立索引列表

idxList = list(range(0, len(val)))
for idx in idxList:
print(idx, val[idx])

利用枚舉對象

val = ["a", "b", "c", "d"]
print(list(enumerate(val))) # [(0, ‘a‘), (1, ‘b‘), (2, ‘c‘), (3, ‘d‘)]
for idx, val in enumerate(val):
print(idx, val)
排序

----------------------------------------

使用內建函數 sorted()，可以對所有可叠代對象排序

sorted(itrearble, key=None, reverse=False)

不改變原對象，以列表的形式返回處理後的結果

默認按照升序排列

s = "acgehijd"
res = sorted(s)
print(res) # [‘a‘, ‘c‘, ‘d‘, ‘e‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘]
print(sorted(s), reverse=True) # [‘j‘, ‘i‘, ‘h‘, ‘g‘, ‘e‘, ‘d‘, ‘c‘, ‘a‘]

指定關鍵字進行排序

def getKey(x):
return x[1]

li = [("s0", 18), ("s1", 17), ("s2", 16)]
res0, res1 = sorted(li), sorted(li, key=getKey)
print(res0) # [("s0", 18), ("s1", 17), ("s2", 16)]
print(res1) # [("s2", 15), ("s1", 17), ("s0", 18)]

-----------------------------------------

使用列表的對象方法

直接修改原對象

參數列表與 sorted()相同

li = [1, 3, 5, 2, 0]
li.sort()
print(li) # [0, 1, 2, 3, 4, 5]
亂序

打亂列表中元素的順序

直接修改原對象

import random
li = [1, 2, 3, 4, 5]
random.shuffle(li)
print(li) # [2, 4, 3, 1, 5]
反轉

使用reverse()直接修改原對象

li = [1, 2, 4, 0]
li.reverse()
print(li) # [0, 4, 2, 1]

使用切片操作獲得新的對象

li = ["ss", "yu", "sfj"]
res = li[::-1]
print(li, res) # ["ss", "yu", "sfj"] [‘sfj‘, ‘yu‘, ‘ss‘]
元組

有序的不可變的元素集合，切片和根據索引獲得單個元素的方式和列表相同。

表示方法

單元組

t = (1,)

多元組

t1, t2 = (1, 2), (2, 3, 9, 0)

復合元組

t = ("abc", [1, 2], 666)

嵌套元組

t = ("rity", (18, "nanchang"))

tuple()函數，用法與list()相同

拆包操作

t = (1, 2, 3)
a, b, c = t
print(a, b, c) # 1 2 3
字典

無序、可變的鍵值對的集合

表示方式

key不能重復，若有重復，後定義的覆蓋前面定義的
key的類型必須是不可變的類型
可變類型（列表，字典，可變集合）
不可變類型（數值，布爾，字符串，元組）
Python的字典是通過哈希（hash）的方式實現的，計算鍵的哈希值，存儲在哈希表中。
person = {"name": "rity", "age": 18}
print(person, type(person)) # {‘name‘: ‘rity‘, ‘age‘: 18} ‘
print(person["name"]) # rity
print(person["age"]) # 18
d = dict.fromkeys("abc", 666)
print(d) # {‘a‘: 666, ‘b‘: 666, ‘c‘:666}
添加元素

d = {"name": "s1", "age": 18}
d["height"] = 175
d["height"] = 180 # 若鍵已經存在，則會修改原來對應的值

不同機器上打印的結果可能不同，因為字典是無序的

print(d) # {‘age‘: 18, ‘name‘: ‘s1‘, ‘height‘: 175}

使用 d0.update(d1)

將兩個字典合並，若舊字典中有對應的 key，則更新；否則添加

d.update({"year": 1997, "height":180})
刪除元素

d = {"name": "s1", "age": 18}

使用 del直接刪除鍵值

刪除不存在的鍵值對會直接報錯

del d["name"]
print(d) # {"age": 18}
del d["name1"] # KeyError: ‘name1‘

dic.pop()

刪除指定的鍵值對，並返回對應的值

刪除不存在的鍵值對會直接報錯

v = d.pop("age")
print(v, d) # 18 {‘name‘: ‘s1‘}

dic.popitem()

刪除按升序排序後的第一個鍵值對，並以元組的形式返回鍵值對

字典為空報錯

res = d.popitem()
print(res) # (‘age‘, 18)

dic.clear()

清空字典，空字典，不是未定義的對象

d.clear()
print(d) # {}
del d
print(d) # 報錯
獲得元素

d = {"name":"Rity", "age": 18}

下標訪問

print(d["name"]) # Rity
print(d["height") # 報錯，鍵不存在

dic.get(key, default)

鍵不存在不會報錯，default是鍵不存在時的返回值，默認為 None

print(d.get("age")) # 18
print(d.get("height")) # None
print(d.get("height", 170) # 170
遍歷

d = {"name":"Rity", "age": 18}
#-------------------------------------

下面三種方法返回的是一個 Dictionary view objects, 雖然以列表的形式展現，但嚴格來說不是列表

不支持索引訪問，但可以使用 list()來轉換成普通的列表對象

特點：當字典被修改後，以下 ks, vs, itms會同步修改

獲取所有的鍵

ks = d.keys()
print(ks) # dict_values([‘Rity‘, 18])

獲取所有的值

vs = d.values()
print(vs) # dict_keys([‘name‘, ‘age‘])

獲取所有的鍵值對

itms = d.items()
print(itms) #dict_items([(‘name‘, ‘Rity‘), (‘age‘, 18)])
#-------------------------------------

字典是可叠代對象，使用 for in

若直接遍歷字典，得到的是它的鍵

for x in d.items():
print(k, end=‘ ‘) # (‘name‘:‘Rity‘) ("age":18)

元組解包

for k, v in d.items():
print(k, v, sep=‘-‘) # name-Rity age-18
集合

無序的，不可隨機訪問的，不可重復的元素集合

與數學中的集合類似，可以進行集合的交、並、差、補等操作。
分為可變集合和不可變集合
set: 可以進行增、刪、改操作
frozenset: 創建好之後，無法再做修改。
可變集合的表示

直接表示

s = {1, 2, 3, 4}
print(s, type(s)) # {1, 3, 4, 2}

set(Iterable)

s1 = set("abc")
s2 = set([1, 2, 3])
print(s1, s2) # {‘a‘, ‘b‘, ‘c‘} {1, 2, 3}

集合推導

參考列表推導

s = {x for x in range(3)}
print(s) # {1, 0, 2}
不可變集合

frozenset(iterable)

fs = frozenset("abc")
print(fs) # frozenset({‘a‘, ‘c‘, ‘b‘})

集合推導

fs = frozenset(x**2 for x in range(1, 6) if x % 2)
print(fs) # frozenset({1, 25, 9})
註意事項

創建空集合

錯誤做法

s = {} # 實際上構建了一個空字典
s = set() # 空集合
集合中的元素必須是可哈希的值（不可變類型）。
集合中元素若出現重復，則會被合並成一個。

多用於給列表元素進行去重

li = {1, 2, 2, 3, 3}
li = list(set(li))
print(li) # [1, 2, 3]
集合的操作

單集合操作
s = {1, 2, 3}
#-----------------------------------------

新增元素

1.集合可變 2.新增元素可哈希

s.add(4)
print(s) # {1, 3, 2, 4}
#-----------------------------------------

刪除元素

1.remove(element)

刪除指定的元素，若無該元素，報錯

s.remove(2)
print(s) # {1, 3}

2.discard(element)

刪除指定的元素，若無該元素，pass

s.discard(2)
print(s) # {1, 3}
s.discard(666)
print(s) # {1, 3}

3.pop(element)

刪除並返回指定元素，若無該元素，報錯

省略 element，不指定刪除元素，進行隨機刪除；集合為空，報錯

s.pop(1)
print(s) # {2, 3}
s.pop()
print(s) # {2}
s.pop()
print(s) # set() //空集合的意思

4.clear()

清空集合，集合依然存在

s.clear()
print(s) # set()
#-----------------------------------------

遍歷集合

1.for in

for v in s:
print(s, sep=‘ ‘) # 1 2 3

2.叠代器

its = iter(s)
print(next(its)) # 1
print(next(its)) # 2
print(next(its)) # 3
多集合操作
intersection(iterable):

求交集，參數是可叠代類型

s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4}
res = s1.intersection(s2)
print(res) # {4, 5}

s1也可以是frozenset，返回結果也是frozenset

可以使用邏輯運算符來完成

print(s1 & s2) # {4, 5}
intersection_update(iterable)

更新調用該方法的對象

s1, s2 = {1, 2, 3, 4, 5}, {9, 8, 8, 5, 4}
s1.intersection_update(s2)
print(s1) # {4, 5}
union(iterable):

求並集，參數是可叠代類型

s1, s2 = {1, 2, 3}, {2, 3, 4}
res = s1.union(s2)
print(res) # {1, 2, 3, 4}

可以使用邏輯運算符來完成

print(s1 | s2) # {1, 2, 3, 4}
update(iterable)
s1, s2 = {1, 2, 3}, {2, 3, 4}
s1.update(s2)
print(s1) # {1, 2, 3, 4}
difference(iterable)

求差集

s1, s2 = {1, 2, 3}, {2, 3, 4}
res = s1.difference(s2)
print(res) # {1}

邏輯運算符

print(s1 - s2) # {1}
difference_update(iterable):
s1, s2 = {1, 2, 3}, {2, 3, 4}
s1.difference_update(s2)
print(s1) # {1}
判定操作

isdisjoint() 兩個集合是否不相交

isuperset() 一個集合是否包含另一個集合

issubset() 一個集合是否包含於另一個集合

時間日歷

time模塊

獲得當前時間戳

獲得從 1970年1月1日到現在的時間秒數

import time
t = time.time()
yearSpan = t / (60 60 24 * 365)
print(yearSpan) # 48.6441059296045
獲得時間元組

根據所給的時間戳，返回當時的時間信息

import time
t = time.time()
res = localtime(t)
print(res) # time.struct_time(tm_year=2018, tm_mon=8, tm_mday=12, tm_hour=10, tm_min=22, tm_sec=4, tm_wday=6, tm_yday=224, tm_isdst=0)
獲得格式化的時間

根據所給定的時間戳，返回一個更加可讀的時間

import time
t = time.time()
res = time.ctime(t)
print(res) # Sun Aug 12 10:33:58 2018
獲得格式化的時間字符串

time.strftime(格式字符串, 時間元組)

res = time.strftime("%y-%m-%d %H:%M:%S", time.localtime())
print(res) # 18-08-12 10:39:28
res = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(res) # 2018-08-12 10:39:50
獲取當前cpu時間

常用來統計一段代碼的執行時間

import time

IDLE環境測試

start = time.clock()
for i in range(0, 10)
print(i, end=‘ ‘)
end = time.clock()
print(end - start) # 0.02806393769252448
休眠

線程休眠

每隔一秒打印一個數字

import time
n = 0
while True:
print(n)
time.sleep(1) # 參數單位是秒
datetiem模塊

模塊內部有多個類：datetime、date、time。使用時選擇合適的類進行操作就行了

獲取當天的日期
import datetime
t = datetime.datetime.now()
print(type(t)) #
print(t) # 2018-08-12 11:04:12.982890
print(t.year) # 2018
print(t.month) # 8
計算n天之後的日期
import datetime
t = datetime.datetime.today()
res = t + datetime.timedelta(days=7)
print(t, res, sep=‘|‘) # 2018-08-12 11:10:31.995501|2018-08-19 11:10:31.995501
獲得兩個日期的時間差
import datetime
first = datetime.datetime(2018, 9, 10, 12, 0, 0)
second = datetime.datetime(2018, 10, 1, 0, 0, 0)
res = second - first
print(res) # 20 days, 12:00:00
註：喜歡python + qun：839383765 可以獲取Python各類免費最新入門學習資料！

python入門系列：Python數據類型