Day01，Python數據類型及常見操作

一、標準數據類型

1、Number（數字）

       int（整數）：-1，1

       bool（布爾類型）：True，False

       float（浮點類型）：1.13，3E-2

       complex（復數）：1+2j，1.1+2.2j

2、String（字符串）：“Hello World!”

3、List（列表）：[1, 2, 3]，[‘a’, ‘b’, ‘c’]

4、Tuple（元組）：(1, 2, 3)

5、Set（集合）：set([1, 2, 3])

6、Dictionary（字典）：{‘name’: ‘Tom’, ‘age’:22}

注：不可變數據類型：Number，String，Tuple；可變數據類型：List，Dictionary，Set

二、字符串常見操作

1、數據類型轉換

str()：將括號內的數據類型轉換成字符串

2、切片、逆序

demo[0:5]：截取字符串下標0到5之間的字符串

demo[0:5:2]：截取字符串下標0-5之間每隔2個字符組成的字符串

demo[::-1]：將字符串逆序

注：下標若為負數代表從字符串右邊開始計數

3、字符串常見方法

str1.find(str2, start=None, end=None)：在str1中查找字符串str2，返回查找的第一個str2的下標，若找不到則返回-1

str1.rfind(str2, start=None, end=None)：從字符串str1右邊開始查找

str1.index(str2, start=None, end=None)：類似find()函數，不同的是若找不到則拋出ValueError異常

str1.rindex(str2, start=None, end=None)：類似rindex()函數

str1.count(str2, start=None, end=None)：統計str2在str1出現的次數

str1.replace(str2, str3, count)：將str1中的str2替換成str3，若指定count，則只替換count次，原變量str1不變，返回新的變量

str1.split(sep=None, maxsplit=-1)：以str2為分割符分割str1，返回一個數組，默認以空格作為分割符，若指定maxsplit，則只分割maxsplit次

str1.capitalize()：字符串第一字母大寫

str1.title()：字符串中每個單詞首字母大寫

str1.startswith(str2)：判斷字符串str1是否以字符串str2開始

str1.endswith(str2)：判斷字符串str1是否以字符串str2結束

str1.lower()：將字符串中字母轉換成小寫

str1.upper()：將字符串中字母轉換成大寫

str1.rjust(width, fillchar=None)：返回一個新字符串右對齊，并使用fillchar填充至width的新字符串，默認填充符是空格

str1.center(width, fillchar=None)：返回一個新字符串居中對齊，并使用fillchar填充至width的新字符串

str1.ljust(width, fillchar=None)：返回一個新字符串左對齊，并使用fillchar填充至width的新字符串

str1.lstrip(chars=None)：默認去除字符串左邊的空格，若指定chars，則去除所有指定字符

str1.rstrip(chars=None)：默認去除字符串左邊的空格

str1.strip(chars=None)：默認去除字符串兩邊的空格

str1.partition(str2)：查找str1中的第一個str2，并以此為分割符，返回分割后的兩個字符串與分割符組成的元組，split函數返回的是列表

str1.splitlines(keepends=None)：以換行符分隔，返回一個列表，keepends參數是個布爾值，表示是否保留換行符到結果中

str1.join(list1)：將str1作為分隔符與列表中各值組成新的字符串

str1.expandtabs(tabsize=8)：將字符串中制表符轉換成空格，默認是8個空格

str1.isalpha()：判斷是否是字母組成的字符串

str1.isalnum()：判斷是否是由字母和數字組成的字符串

str1.isspace()：判斷是否是空白字符組成的字符串，例\t、\n、\r

str1.isidentifier()：判斷是否符合標準變量命名規范

str1.isdecimal()，str1.isdigit()，str1.isnumeric()三個函數的區別：

4、字符串格式化輸出

 1  # 方式一
 2  info = """
 3      info of %s
 4  name: %s
 5  age: %s
 6  job: %s
 7  salary: %s
 8  """%(name, name, age, job, salary)
 9 
 10 # 方式二
 11 info2 = """
 12     info of {_name}
 13 name: {_name}
 14 age: {_age}
 15 job: {_job}
 16 salary: {_salary}
 17 """.format(_name=name,
 18            _age=age,
 19            _job=job,
 20            _salary=salary)
 21 
 22 # 方式三
 23 info3 = """
 24     info of {0}
 25 name: {0}
 26 age: {1}
 27 job: {2}
 28 salary: {3}
 29 """.format(name, age, job, salary)

三、數據運算

1、算數運算     

+   加
-   減
*   乘
/   除
%   取模，返回除法的余數
**   冪
//   返回商的整數部分

2、比較運算

==     等于，比較對象是否相等
!=, <>   不等于，比較對象是否不相等
>      大于
<      小于
>=     大于等于
<=     小于等于

3、賦值運算

=      簡單的賦值運算符
+=     c+=a等效于c=c+a
-=     c-=a等效于c=c-a
*=     c*=a等效于c=c*a
/=     c/=a等效于c=c/a
%=     c%=a等效于c=c%a
**=     c**=a等效于c=c**a
//=     c//=a等效于c=c//a

4、邏輯運算

and    布爾“與”
or     布爾“或”
not    布爾“非”

5、成員運算

in     如果在指定的序列中找到值返回True，否則返回False
not in      如果在指定的序列中沒有找到值返回True，否則返回False

6、身份運算

is     判斷兩個標識符是不是引用自一個對象
is not       判斷兩個標識符是不是引用自不同對象

7、位運算

&   按位與運算
|   按位或運算
^   按位異或
~   按位取反
<<  左移動
>>  右移動

8、運算優先級

四、列表常見操作

1、增加

list1.append()：在列表尾部添加

list1.insert(index, obj)：在指定下標添加obj元素

list1.extend(list2)：將列表list2的所有值添加到list1

list1+list2：列表list1與list2組成新的列表返回

2、刪除

list1.pop()：刪除列表最后的值，返回刪除的值

list1.remove(obj)：刪除列表中指定的內容

del list1[index]：刪除列表中指定下標的內容

3、修改

list1[index]=obj：修改列表中指定下標的內容

4、查找

list1.index(obj)：返回查找的內容的下標，若找不到則拋出ValueError異常

list1.count(obj)：統計查找內容出現的次數

if obj in list1：判斷obj是否在列表中

if obj not in list1：判斷obj是否不在列表中

5、排序

list1.sort(reverse=False)：列表排序，默認升序，列表變量會被永久修改，若reverse=True則降序

sorted(list1, reverse=False)：返回排序的新列表，原列表數據不變，若reverse=True則降序

list1.reverse()：列表順序翻轉

6、統計計算

min(list1)：返回列表中最小值

max(list1)：返回列表中最大值

sum(list1)：返回列表中所有值的和

7、列表解析

8、復制列表

list1與list3是相同的內存空間，list2是全新的

淺復制與深復制的區別：

 1  names = ["tom", "jerry",["alex", "jordan"], "marry", "jack"]
 2  names2 = names.copy()   # copy 淺復制，只復制第一層，第二層內容不會復制
 3  print(names, names2)
 4  names[0] = "dog"
 5  names2[2][0] = "cat"
 6  print(names, names2)
 7  #  ----------------------------------------
 8  import copy
 9  n1 = ["tom", "jerry",["alex", "jordan"], "marry", "jack"]
 10 n2 = copy.deepcopy(n1)   # deepcopy 深復制，完全復制內存內容
 11 print(n1, n2)
 12 n1[0] = "dog"
 13 n2[2][0] = "cat"
 14 print(n1, n2)
 15 
 16 # 淺copy的三種方式
 17 person = ["jack", ["男", 25]]
 18 # 1
 19 p1 = copy.copy(person)
 20 # 2
 21 p2 = person[:]
 22 # 3
 23 p3 = list(person)

五、元組

元組又叫只讀列表，一旦創建，便不能再修改，它只有兩個方法，一個count，一個index。

語法

names = ("tom","jack","eric")

六、字典常見操作

1、增刪改查

dict1 = []
dict1['name'] = 'Tom'   # 增加
del dict1['name']       # 刪除
dict1['name'] = 'Jerry' # 修改
dict1.get('name')       # 查找

2、其它方法

dict1.keys()：返回字典中所有key組成的列表
dict1.values()：返回字典中所有vlaue組成的列表
for key, value in dict1.items()：循環打印
dict1.update(dict2)：將字典dict2中的內容更新到字典dict1，若key相同則更新value，不同則添加鍵值對
dict.fromkeys([key1, key2, key3…], value)：初始化一個字典

七、集合常見操作

set和dict類似，也是一組key的集合，但不存儲value。由于key不能重復，所以在set中，沒有重復的key。

set1.add(obj)：添加元素

set1.pop()：任意刪除集合中的一個值，返回該值

set1.remove(obj)：刪除元素，若值 不存在會報錯

set1.discard(obj)：刪除元素，若值不存在也不會報錯

集合之間的運算

 1  s1 = set([1, 2, 3])
 2  s2 = set([2, 4, 5])
 3  # 交集
 4  print(s1 & s2)
 5  print(s1.intersection(s2))
 6  # 并集
 7  print(s1.union(s2))
 8  print(s1 | s2)
 9  # 差集 in set1 but not in set2
 10 print(s1 - s2)
 11 print(s1.difference(s2))
 12 # 子集
 13 s3 = set([1, 2, 3])
 14 s4 = set([1, 2])
 15 print(s4.issubset(s3))
 16 # 父集
 17 print(s3.issuperset(s4))
 18 # 對稱差集   把相同的去掉組成新的集合
 19 print(s1.symmetric_difference(s2))
 20 print(s1 ^ s2)
 21 s5 = set([4, 5])
 22 # 判斷兩個集合是否有交集，有即返回false
 23 print(s3.isdisjoint(s5))

八、補充

1、dict與list的比較

dict有以下特點：

        查找和插入的速度極快，不會隨著key的增加而變慢

        需要占用大量的內存，內存浪費多

而list相反：

        查找和插入的時間隨著元素的增加增加

        占用空間小，浪費內存很少