Python基礎（1）——變量和數據類型[xiaoshun]

時間 2020-11-29

標籤 python json api 數組網絡 app 函數測試編碼 url 欄目 Python 简体版

原文原文鏈接

目錄python

1、變量json

1.概述api

Variables are used to store information to be referenced（引用）and manipulated（操做） in a computer program.數組

2.聲明網絡

（1）命名規則app

變量名只能是字母、數字或下劃線的任意組合；
第一個不能是數字
關鍵字不能做爲變量名

（2）定義函數

name1 = 'Lu'
name2 = name1
name1 = 'MJJ'
print(name1, name2)

-->:
MJJ Lu

（3）刪除測試

name1 = 'Lu'
del name1
print(name1)

-->:
NameError: name 'name1' is not defined

　變量的生命週期：無指向時，纔會在內存中被回收。編碼

2、數據類型url

1.數字

（1）分類

Python 支持三種不一樣的數值類型：

整型(Int) ：不帶小數點。Python3 整型是沒有限制大小的，能夠看成 Long 類型使用，Python3 沒有 Python2 的 Long 類型；
浮點型(float)：浮點型由整數部分與小數部分組成，浮點型也可使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）；
複數( (complex)) - 複數由實數部分和虛數部分構成，能夠用a + bj,或者complex(a,b)表示，複數的實部a和虛部b都是浮點型。

（2）類型轉換

int(x) 將x轉換爲一個整數。
float(x) 將x轉換到一個浮點數。
complex(x) 將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) 將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。Python中複數不支持強轉，但能夠經過real和image方法獲取到實部和虛部的值。

（3）運算

不一樣類型的數混合運算時會將整數轉換爲浮點數。

/：老是返回一個浮點數。
//：獲得的並不必定是整數類型的數，它與分母分子的數據類型有關係。

　　　　　　　　　　7 // 2=3, 7.0 // 2=3.0,7 // 2.0=3.0

**：冪運算。
%：取餘。

在交互模式中，最後被輸出的表達式結果被賦值給變量 "_"。「_」應該爲只讀變量。

（4）數學函數

abs(x)：返回數字的絕對值，如abs(-10) 返回 10。
max(x1, x2,...) ：返回給定參數的最大值，參數能夠爲序列。
min(x1, x2,...) ：返回給定參數的最小值，參數能夠爲序列。
pow(x, y)：x**y 運算後的值。
sqrt(x) ：返回數字x的平方根。

（5）隨機數函數

2.字符串

（1）切片，索引，拼接

str[a:b],str[a:b:c]

a,b爲參數。從字符串指針爲a的地方開始截取字符，到b的前一個位置（由於不包含b）；
若是a,b均不填寫，默認取所有字符；
若是a填寫，b不填寫（或填寫的值大於指針下標），默認從a開始截取，至字符串最後一個位置；
若是a不填寫， b填寫，默認從0位置開始截取，至b的前一個位置；
若是a爲負數，默認從尾部某一位置，開始向後截取，最後一個位置爲-1
若是a>=b, 默認輸出爲空。
[a:b:c] 表示的是從頭至尾，步長爲c。第一個冒號兩側的數字是指截取字符串的範圍,第二個冒號後面是指截取的步長。
[::-1]：字符串倒序

萬惡的字符串拼接：

　　python中的字符串在C語言中體現爲是一個字符數組，每次建立字符串時候須要在內存中開闢一塊連續的空，而且一旦須要修改字符串的話，就須要再次開闢空間，萬惡的+號每出現一次就會在內從中從新開闢一塊空間。

字符串是一種不可變數據類型，不能夠改變。能夠用截取的方式，拼接的方式從新組合成新的字符串。

　　　　　　　　　　　str1[0] = "H"

　　　　　　　　　　　TypeError: 'str' object does not support item assignment.

（2）轉義

\(在行尾時)：續行符。代碼過長時，能夠用續航符進行換行編寫，且續行符以後，續行符後面什麼都不能出現（包括空格），必須換行（必須換行寫內容）

　　　　　　　　a = "ajkfhajkfhkjahfkahfkhakfhkdafafafaddafafdafafadfafafafafafadefgg" \

　　　　　　　　　　"hfakjfhkah"

\\ 反斜槓符號，\' 單引號，\" 雙引號：

　　　　　　　　print(str1 + "\\")print("\'" + str1 + "\'")

\a 響鈴，命令行交互模式中能夠實現。
\b 退格(Backspace)，\000 空，\n 換行，等

（3）運算

「+」：拼接
「str*number」：重複輸出number次str
[]：獲取索引
[:]:截取，切片，左閉右開
in,not in :成員邏輯運算符
R/r：原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符，引入文件路徑時經常使用。

　　　　　　　　print(r"hello \' word!")

　　　　　　　　print("hello \' word!")

（4）格式化輸出

　　%和format（）函數使用、f-string字面量格式化字符串，是新的格式化字符串的語法。

（5）字符串操做

str.capitalize()，無參數，將字符串的第一個字符轉換爲大寫，其他轉換成小寫。首字符爲非字母，則不轉換，其他轉爲小寫。
str.center(width[, fillchar])，返回一個指定寬度且原str居中的新字符串，fillchar 爲填充的單個字符，默認爲空格。

　　　　參數：width，寬度；fillchar，能且只能爲一個字符。

　　　　注意：

　　　　　　a、若是 width 小於字符串寬度直接返回字符串，不會截斷；

　　　　　　b、fillchar 只能是單個字符。

str.count(sub[, start= 0][,end=len(string)])，統計子字符串sub裏某個字符串出現的次數。可選參數爲在字符串搜索的開始（默認爲0）與結束位置（默認爲len（string））。

str1 ='python' * 3
print(str1.count('p'))
print(str1.count('p', 1))   # 包含起始位置
print(str1.count('p', 1, -6))   # 不包含結束位置

-->:
3
2
1

str.join(sequence)，將序列seq中的元素以指定的字符串str鏈接返回一個新的字符串。

　　　　參數：seq，元組、列表、字典、字符串。字典只能鏈接鍵值key。

str1 = '\t'
str2 = 'python'
list1 = [i*2 for i in str2]
print(str1.join(str2))
print(str1.join(list1))

-->:
p	y	t	h	o	n
pp	yy	tt	hh	oo	nn

str.split(str="", num=string.count(str))，指定分隔符對字符串進行切片。經常使用做數據的分析提取。

　　　　參數：str，分隔符，默認爲全部的空字符，包括空格、換行(\n)、製表符(\t)等；num，分割次數。默認爲 -1, 即分隔全部，分割爲 num+1 個子字符串。

　　　　返回值：元素爲字符串的列表。

　　　　　　爬蟲時，圖片名獲取：

url_str = "http://www.baidu.com/python/image/123456.jpg"
print(url_str.split('/')[-1])

-->:
123456.jpg

str.strip([chars])，移除字符串頭尾指定的字符（默認爲空格）或字符序列chars，返回新字符串。

　　　　注意：

　　　　　　a、該方法只能刪除開頭或是結尾的字符，不能刪除中間部分的字符。

　　　　　　b、若是不帶參數，默認是清除兩邊的空白符，例如：/n, /r, /t, ' '等

str1 = '\tpython\t' * 3
print(str1.strip())

-->:
python		python		python

　　　　　　c、帶有參數的時候，這個參數能夠理解一個要刪除的字符的列表，刪除多個字符時，只要頭尾有對應其中的某個字符即刪除，不考慮順序，直到遇到第一個不包含在其中的字符爲止。

str1 = 'a111123\t132231b213321312==3213122132*31123132'
print(str1.strip('123ab\t'))
# 等價於
for i in str1:
    if i in '123ab\t':
        str1 = str1.strip(i)

-->:
==3213122132*

（待補充）

3.列表

（1）基況

　　列表元素類型能夠不一致，和C數組不同（相似ndarray）。列表元素能夠修改，因此作列表有關操做時，要注意原列表的元素是否被更改了（深淺拷貝！！！）。

list1 = [i for i in range(10)]
list2 = list1    # list2 = list1.copy()
print(list1, list2)
list2[0] = 100
print(list1, list2)

-->:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[100, 1, 2, 3, 4, 5, 6, 7, 8, 9] [100, 1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）基操

下標索引查找或者更改（列表可變）
截取、切片：[:]；間隔截取：[:::]
拼接組合：「+」；重複：「*」
成員邏輯判斷：in；not in

（3）列表嵌套

不支持花切，只能分層操做。

list1 = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(list1[1:][:])
print(list1[[0], [0]])

-->:
TypeError: list indices must be integers or slices, not tuple
[[4, 5, 6], [7, 8, 9]]

（4）常見內建函數和列表方法

內建函數：

len(list)，返回列表元素個數
min/max(list)，返回列表最小值/最大值

　　　　元素所有爲數字類型時，直接根據值的大小比較。當其中的元素所有爲字符串類型(string)時，則比較的是每一個字符串元素的第一個字符的 ASCII 的大小。

list(seq)，將元組或字符串轉換成列表。

str1 = "python"
tup1 = ('1', '2', '3')
dict1 = {'a': 1, 'b': 2, 'c': 3}
print(list(str1))    # 每一個字符循環一遍，相似列表生成式
print(list(tup1))
print(list(dict1))    # 默認爲KEY
print(list(dict1.values()))

-->:
['p', 'y', 't', 'h', 'o', 'n']
['1', '2', '3']
['a', 'b', 'c']
[1, 2, 3]

enumerate(list),以（index, value）小元組形式返回列表的下標和下標對應的值。

list1 = [i for i in range(10)]
for index, value in enumerate(list1):
    print(index, value)

-->:
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
8 8
9 9

待補充

list對象的方法：

list.append(obj)，在列表末尾添加新的對象，返回值爲None，修改原列表。倘若不但願原列表被改，記得先copy()。

list1 = [i for i in range(10)]
list2 = list1.append(10)
print(list2, type(list2), list1)

-->:
None <class 'NoneType'> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list.count(obj)，返回某個元素在列表中出現的次數。不能夠像str.count()指定搜索區間，搜索整個列表。
list.extend(seq)，在列表末尾一次性追加另外一個序列中的多個值（用新列表擴展原來的列表），無返回值。list.append()的循環增強版。

　　　參數：
　　　　seq-- 能夠是列表、元組、集合、字典，若爲字典,則僅會將鍵(key)做爲元素依次添加至原列表的末尾。

list.index(x[, start[, end]])，返回X在列表中第一次匹配到的索引。若是沒找到，則拋出異常！

　　　　參數：
　　　　x-- 查找的對象。
　　　　start-- 可選，查找的起始位置。
　　　　end-- 可選，查找的結束位置。

list.insert(index, obj)，將指定對象插入列表的指定位置，無返回值，在原列表操做修改。

list.pop([index=-1])，移除列表中的一個元素（默認最後一個元素，不能超過len(list)，不然拋異常！），而且返回該元素的值。在原列表操做刪除。
list.remove(obj)，移除列表中某個值的第一個匹配項，無返回值。在原列表操做刪除。沒法指定匹配區間。

　　　　刪除重複元素，不要用由前到後for循環。由於刪除一個後，後面的元素迴向前補齊，而循環下標仍是會正常加1，會致使後面的循環下標與元素不對應。
　　　　　　方法一：從後往前[::-1]循環開始刪除。

　　　　　　方法二：用Python原生態方法，現用set（）列表變成集合（集合惟一性），再用list（）將集合變成列表。

list1 = [1, 2, 'a', 'l', 'a', 1, 1, 2, 3]
set1 = set(list1)
list1 = list(set1)
print(list1)

-->:
[1, 2, 3, 'l', 'a']

ist.reverse()，翻轉180°，無返回值。
list.sort( key=None, reverse=False)，排序。無返回值，原列表操做。默認reverse=False升序。
待補充

4.元組

（1）基況

　　與列表相似，但元素不能修改，又叫只讀列表。和str同樣，操做都會生成新的元組。

（2）基操

下標索引訪問查找
截取、切片、間隔截取[:::]訪問
拼接組合：「+」；重複：「*」
成員邏輯判斷：in；not in

（3）常見內建函數及方法

函數：

len（）、max（）、min（）
tuple（iterable）：將可迭代系列轉換爲元組。

方法：（只有兩個，由於元組不可變）

count（）
index（）

（4）元組注意事項

　　a、元組中只包含一個元素時，須要在元素後面添加逗號，不然括號會被看成運算符使用：

Tuple1 =（3）--》<class 'int'>Tuple = (3,)--》<class 'tuple'>

　　b、tuple的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組。

　　c、tuple中的「不變」，指的是「指向不變」，可是指向裏面的內容是能夠變的。

tuple1 = ([1, 2, 3, 9, 5], [1, 1, 2, 3], 100)
tuple1[0][0] = 100
print(tuple1)

-->:
([100, 2, 3, 9, 5], [1, 1, 2, 3], 100)

5.字典

（1）基況

　　字典是另外一種可變容器模型，且可存儲任意類型對象。key-value鍵值對形式。

（2）鍵和值

鍵值必須惟一，值沒必要，但同一個鍵值被賦值兩次，後一次賦值會被記住；
值能夠是任何數據類型（標準的、用戶自定義的），但鍵值必須是不可變的數據類型：字符串、元組、數字；
對字典操做，通常經過鍵值（特殊的索引）進行操做：讀取、修改、新增、刪除等
經過鍵值對字典進行邏輯操做：key in/not in dict

（3）常見內建函數和方法

函數：

len（dict），計算字典元素個數，即鍵的總數。

方法：

dict.clear()，清空字典內全部元素，字典不會被刪除，無返回值無參數。
dict.copy()，返回一個字典的淺拷貝。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = dict1.copy()        # 深拷貝父對象（一級目錄），子對象（二級目錄）不拷貝，仍是引用
dict2['name'][0] = 'LU__'   # 子對象爲引用
dict2['age'] = [100, 16]    # 父對象爲拷貝
print(dict2)
print(dict1)

-->:
{'name': ['LU__', 'mjj'], 'age': [100, 16], 'sex': ['man', 'wom']}
{'name': ['LU__', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}

　　深拷貝須要用到copy模塊的deepcopy()函數，copy.deepcopy(dict)

dict.fromkeys(seq[, value])，建立一個值全同樣的字典。不一樣的key對應同樣的value。

　　　　參數：

　　　　　　seq，序列中的元素爲字典的鍵值

　　　　　　value，默認爲None。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = dict1.fromkeys('NAME')
dict3 = dict.fromkeys([1, 2, 3], [10, 10])
print(dict2)
print(dict3)
print(dict1)

-->:
{'N': None, 'A': None, 'M': None, 'E': None}
{1: [10, 10], 2: [10, 10], 3: [10, 10]}
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}

dict.get(key, default=None)，返回指定鍵值對應的值，若是鍵值不在字典中返回默認值None。
dict.items()，以列表形式（並不是直接的列表（dict_items迭代對象），若要返回列表值還需調用list函數）返回可遍歷的(鍵, 值) 元組數組，參數無。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict1_item = dict1.items()
print(dict1_item)
print(type(dict1_item))
print(list(dict1_item))
print(list(dict1))  # 只獲得鍵值列表
for i, j in dict1_item:
    print(i, j)

-->:
dict_items([('name', ['lu', 'mjj']), ('age', [18, 16]), ('sex', ['man', 'wom'])])
<class 'dict_items'>
[('name', ['lu', 'mjj']), ('age', [18, 16]), ('sex', ['man', 'wom'])]
['name', 'age', 'sex']
name ['lu', 'mjj']
age [18, 16]
sex ['man', 'wom']

dict.keys()，返回一個可遍歷可迭代對象dict_kys，可使用 list() 來轉換爲列表。參數無，返回一個迭代器。pthon2.x直接返回一個列表。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
for i in dict1.keys():
    print(i)

dict.setdefault(key, default=None)，和 get()方法相似, 若是鍵不已經存在於字典中，將會添加鍵並將值設爲默認值。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
print(dict1.setdefault('name'))
print(dict1.setdefault('birthday', ['1995-8-6', '1995-3-9']))
print(dict1)

-->:
['lu', 'mjj']
['1995-8-6', '1995-3-9']
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom'], 'birthday': ['1995-8-6', '1995-3-9']}

dict.update(dict2)，把字典參數 dict2 的 key/value(鍵/值) 對更新到字典 dict 裏，無返回值。

dict1 = {'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom']}
dict2 = {'birthday': ['1995-8-6', '1995-3-9']}
print(dict1.update(dict2))
print(dict1)

-->:
None
{'name': ['lu', 'mjj'], 'age': [18, 16], 'sex': ['man', 'wom'], 'birthday': ['1995-8-6', '1995-3-9']}