(一) pyhon 基礎語法(數值字符串元組列表字典)

時間 2019-11-19

標籤 pyhon 基礎語法數值字符串列表字典简体版

原文原文鏈接

一、python的數據類型：數值字符串列表元組字典；python

數值類型包括；整型(int) 長整型(long) 浮點型(float) 複數型字符串；linux

能夠經過type() 來查看是什麼類型的；bash

註釋：len()只支持字符串類型,不支持浮點數和整數；數據結構

1:整型：表示的數字,好比 0 100 -100 等；整數又分爲正整數和負整數；app

整數範圍： 2**32 次方；函數

In [8]: a = 123
In [9]: type(a)
Out[9]: int

In [10]: 2**32
Out[10]: 4294967296
In [11]: 2**31
Out[11]: 2147483648

註釋：整數的範圍： -2147483648 到 2147483648 加起來恰好；4294967296ui

2：長整型 long 後面會加L；或者是定義的值很大時, 或者在自定的數值後面加L也能夠；code

In [12]: a = 129999999999999999999999999999999999999
In [14]: a
Out[14]: 129999999999999999999999999999999999999L

In [15]: a = 100l
In [16]: a
Out[16]: 100L
In [17]: type(a)
Out[17]: long

3:浮點型；後面帶小數點 0.0 12.0 -18.8 3e+7對象

In [18]: a = -0.18

In [19]: type(a)
Out[19]: float

In [20]: a = 3e+7

In [21]: type(a)
Out[21]: float

4:複數型；後面加 j -3.14j 排序

In [22]: a = -3.14j

In [23]: type(a)
Out[23]: complex

5:字符串 str

給變量賦值字符串時,能夠有三種方法: 單引號雙引號三引號 /n 表示換行符；

註釋：三引號能夠用做定義字符串,也能夠用做註釋；再使用定義字符串時,必須是三個單引號,或者三個雙引號,不能單雙混用；

In [24]: a = 'abc'

In [25]: type(a)
Out[25]: str

In [26]: a = "abc"

In [27]: type(a)
Out[27]: str

/n 表示換行符；

In [33]: a = """hello\nworld"""

In [34]: a
Out[34]: 'hello\nworld'

In [35]: print a
hello
world

In [30]: a = '''hello
    ...: world'''

In [31]: a
Out[31]: 'hello\nworld'

In [32]: print(a)
hello
world

註釋：字符串時一個序列,那麼針對序列操做的時候能夠經過索引和切片來操做,

索引：第一個字符表示0,依次日後,最後一個字符能夠用 -1 表示；

In [37]: a
Out[37]: 'abcde'
In [38]: a[0]
Out[38]: 'a'
In [39]: a[1]
Out[39]: 'b'
In [40]: a[4]
Out[40]: 'e'
In [41]: a[-1]
Out[41]: 'e'

切片：好比咱們須要去 ab 兩個字符,固然能夠用鏈接符 + 號 a[0]+a[1]

In [42]: a[0]+a[1]
Out[42]: 'ab'

In [43]: a[0:2]
Out[43]: 'ab'
In [44]: a
Out[44]: 'abcde'

也可使用切片的方式： a[0:2] 0表示a的下標依次 2 表示 c 的下標,不過不顯示；不過 0 也能夠省略的； a[:2]

均可以省略表示所有內容； a[:]

a[::2] 表示步長值爲 2 ，表示隔兩步一取; 顯示爲 ace；

註釋：a[-1] 表示e,最後一個字母,

也能夠從後往前取,好比 a = abcde 若是取 bc 的話, 那就是 a[-4:-2]

In [58]: a = 'abcde'
In [59]: a
Out[59]: 'abcde'

In [60]: a[-4:-2]
Out[60]: 'bc'

默認是從左到右的；也能夠從右到左的；好比 a = abcde 若是取 db 的話, 那就是 a[-2:-4:-1] -1 表示方向

In [61]: a = 'abcde'

In [62]: a[-2:-4:-1]
Out[62]: 'dc'

四、元組：序列包括字符串列表元組；

序列的主要特色就是可使用索引操做切片操做；索引是取某一個字符, 切片取一組字符；

序列的基本操做：

len() 求序列的長度；

+ 用來鏈接兩個序列；

* 重複序列元素；

in 判斷元素是否存在序列中；

max() 返回最大值；

min() 返回最小值；

cmp(x,y) 判斷兩個序列是否相等；

In [63]: a = 'abcde'

In [64]: len(a)                 #求字符串長度;
Out[64]: 5

In [65]: a + 'f'                #字符串相加;
Out[65]: 'abcdef'
In [69]: b = 5

In [70]: b + 6                  #數值相加;
Out[70]: 11

如上圖：len 能夠用來求數據的長度；

+ 加號,能夠用來序列相加；能夠是同一類型相加(字符串相加數值相加)，也能夠不一樣類型( 字符串和數字相加)----不過須要轉換一下；

In [84]: name = 'wo jin nian'

In [85]: h = 'sui'

In [86]: name + str(age) + h
Out[86]: 'wo jin nian24sui'

# 號表示重複,後跟數字,表示重啓的前面的多少次；

'#' * 50
Out[89]: '##################################################'

in 判斷元素是否在序列裏；

判斷 a 是否在 a 這個序列中, 存在則返回true，不存在則返回flase；已知 a = 'abcde'

In [91]: a= 'abcde'

In [92]: 'a' in a
Out[92]: True

In [93]: 's' in a
Out[93]: False

還有not in 表示取反, 'f' not in a 表示 f 若是不在 a 這個序列裏,則返回true, 若是在則返回flase；

In [94]: 'f' not in a
Out[94]: True

In [95]: 'f' not in a+'f'
Out[95]: False

max() 求最大值 min() 求最小值

In [99]: b = '12345'
In [102]: type(b)
Out[102]: str

In [100]: max(b)
Out[100]: '5'

In [101]: min(b)
Out[101]: '1'

註釋：max()和min() 只支持序列(字符串類型)
cmp(x, y) 比較兩個序列是否相等；若是 x > y 則返回正整數, x < y 返回負整數, x = y 返回0 ；

In [113]: a= 'abcde'

In [114]: cmp(a, 'abcde')       # a 則表示上面的變量,它倆相等;因此返回是0 ;
Out[114]: 0

In [115]: cmp(a, 'abcdef')      # a 小於右邊的字符串,因此返回是負整數 -1 ;
Out[115]: -1

In [116]: cmp(a+'g', 'abcdef')    # a 大於右邊的字符串,因此返回是正整數 1 ;
Out[116]: 1

註釋：兩個序列是否相等；若是 x > y 則返回正整數, x < y 返回負整數, x = y 返回0 ；

五、元組() 能夠存儲一系列的值,和字符串同樣是不可變的(裏面的內容不能夠改變)

如何定義元組呢？多個元素用 , 逗號分開；

t = ('a',1,(1,)) 表示裏面存放的字符串 a 數字 1 , 又存放了元組 1 ;

In [119]: t = ('a',1,(1,))

In [120]: t
Out[120]: ('a', 1, (1,))

In [121]: type(t)
Out[121]: tuple

元組一般用於接受函數的返回值；以下；

定義t = (a, 'b', 'c') 這三個元素,其中a是表示以前定義的變量abcde,未加引號, b 和 c 表示字符串；

而後經過三個變量去接收這個值； first 第一個值 second 第二個值 third 第三個值；

In [122]: t = (a, 'b', 'c')
In [123]: t
Out[123]: ('abcde', 'b', 'c')

In [127]: first, second, third = t
In [128]: first
Out[128]: 'abcde'
In [129]: second
Out[129]: 'b'
In [130]: third
Out[130]: 'c'

t.count

python裏面的變量字符串序列都稱爲對象；

元組和字符串同樣屬於序列類型,也能夠經過序列和切片操做；

元組拆分；

t = ('a', 'b', 'c') A, B, C = t

六、列表：是一種有序項目的項目的數據結構,列表是可變數據類型的數據；

建立列表；

list = [] 建立空列表；

list2 = list() 經過list()函數來建立空列表；

list3 = ['a',1,2] 建立列表；

In [146]: list1 = []             #建立空列表;
In [148]: type(list1)
Out[148]: list

In [149]: list2 = list()        #經過list函數來建立列表：
In [150]: type(list2)
Out[150]: list
In [151]: list2
Out[151]: []

In [152]: list3 = ['a',1,(1,),['hello', 'python']]     #建立list列表;
In [153]: list3
Out[153]: ['a', 1, (1,), ['hello', 'python']]

In [154]: len(list3)
Out[154]: 4

列表的特性：列表的值時可變的；經過索引的方式把list3的值第 0 位變成 a；

In [167]: list3
Out[167]: ['b', 1, (1,), ['hello', 'python']]
In [168]: list3[0]
Out[168]: 'b'
In [169]: list3[0] = a
In [170]: list3
Out[170]: ['abcde', 1, (1,), ['hello', 'python']]

三、往空列表裏追加： list2爲以前建立的空列表；經過 list2 = list() 函數建立；

給列表添加元素： list2.append( )

In [181]: list2.append('linux')

In [182]: list2
Out[182]: ['linux']

In [183]: list3 + list2
Out[183]: ['abcde', 1, (1,), ['hello', 'python'], 'linux']

註釋：而後能夠把list3和list2 相加;

也能夠重複以前的列表，用 * 號； (list3) * 2 (list3+list2) * 2 先加再乘；

In [185]: (list3) * 2
Out[185]: ['abcde', 1, (1,), ['hello', 'python'], 'abcde', 1, (1,), ['hello', 'python']]

Out[186]: ['linux', 'linux']
In [187]: (list3 + list2) * 2
Out[187]: 
['abcde',
 1,
 (1,),
 ['hello', 'python'],
 'linux',
 'abcde',
 1,
 (1,),
 ['hello', 'python'],
 'linux']

六、刪除列表中的元素：兩種方式以下； del list2 表示刪除真個list2 列表；

###可使用help(list.remove)查看幫助等；

del list3[4] 須要知道它的下標纔可以刪除； 0 1 2 3 -l (最後表示 -1 )

list.remove(1) #默認刪除是first第一個value；

In [204]: list3
Out[204]: ['abcde', 1, (1,), ['hello', 'python']]

In [205]: del list3[-1]                #第一種方式,刪除最後一個元素;
In [206]: list3
Out[206]: ['abcde', 1, (1,)]

In [209]: list3.remove(1)              #刪除第一個元素;

In [210]: list3
Out[210]: ['abcde', (1,)]

七、查找； in

'a' in list3 表示 a 是否在這個列表,若是在,返回true,若是不在返回flase；

'a' not in list3 表示a 是否在這個列表,若是在,返回flase,不過則返回true；

In [210]: list3
Out[210]: ['abcde', (1,)]

In [211]: 'a' in list3
Out[211]: False
In [215]: 'abcde' in list3
Out[215]: True

In [216]: 'a' not in list3
Out[216]: True

In [217]: 'abcde' not in list3
Out[217]: False

修改字符；列表 list3 的 0 位修改成 b ;

list3[0] = 'b'

In [218]: list3
Out[218]: ['abcde', (1,)]

In [219]: list3[0] = 'b'

In [220]: list3
Out[220]: ['b', (1,)]

list.insert 插入空的列表；

In [220]: list3
Out[220]: ['b', (1,)]

In [221]: list3.insert(1, list1)

In [222]: list3
Out[222]: ['b', [], (1,)]
插入了一個空列表;

給空列表裏寫入值； list3[1].append('abc')

In [225]: list3[1].append('abc')

In [226]: list3
Out[226]: ['b', ['abc'], (1,)]

列表排序： list.sort

list3.sort()

In [227]: list3
Out[227]: ['b', ['abc'], (1,)]

In [228]: list3.sort()

In [229]: list3
Out[229]: [['abc'], 'b', (1,)]

反轉(最後一位變成了第一位)； list.reverse

In [229]: list3
Out[229]: [['abc'], 'b', (1,)]

In [230]: list3.reverse()

In [231]: list3
Out[231]: [(1,), 'b', ['abc']]

list.pop 根據下標來刪除,當時會返回一下當前值；

如咱們刪除list3 中下標爲 1 的,使用 list.pop 不只會刪除,還會返回刪除的這個值；

In [231]: list3
Out[231]: [(1,), 'b', ['abc']]

In [232]: list3.pop()
Out[232]: ['abc']

In [233]: list3
Out[233]: [(1,), 'b']

註釋：默認什麼也不加,會刪除最後一個；如上圖例；

list.ectend，可迭代的,會把新增的追加列表裏； list3.extend(range(5))

In [248]: range(5)
Out[248]: [0, 1, 2, 3, 4]

In [249]: list3.extend(range(5))

In [250]: list3
Out[250]: [(1,), 'b', 0, 1, 2, 3, 4]

list.exxend 會把元素迭代追加進去；

list3.exxtend('abcde')

In [255]: list3.extend('abcde')

In [256]: list3
Out[256]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

也能夠追加元組： list3.extend(('t1', 't2'))

註釋：字符串元組列表都是可迭代的對象；可迭代的能夠經過for循環去訪問；

list.count(value) 若是判斷這個value值在當前的列表裏,則返回是一個整數,不然不在則返回0；

In [282]: list3
Out[282]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

In [284]: list3.count('b')
Out[284]: 2

In [285]: list3.count('e')
Out[285]: 1

In [286]: list3.count('x')
Out[286]: 0

list.index(value) 表示返回索引號；

In [287]: list3
Out[287]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']

In [288]: list3.index('b')
Out[288]: 1

In [289]: list3.index('d')
Out[289]: 10

In [290]: list3.index('e')
Out[290]: 11

八、字典：是python裏面的數據結構,字典的對象value是可變的,可是字典的鍵值key是不可變的,一個字典可使用不一樣類型的鍵值(元組)；不能使用列表list,由於列表是可變的, 由於字典是hash 表顯示是無序的；

可用來存儲一我的年齡身高性別等；

固然字符串也能夠存儲的,可是若是有的姓名不是3個,那就取得不全的；

info = 'tom 180 man'

info[0:3]
'tom'
固然也能夠存儲元組裏,可是元組一旦定義完以後,裏面的元素就不能更改,那麼若是增長聯繫人等信息就沒法添加了；

固然也能夠存儲到列表裏, 可是未來取數據也比較麻煩,經過下標來取,不知道索引就沒法取了；

以下：先建立一個list1 list2 list3 並用zip函數把他們鏈接到一塊兒；而後把這些信息放到字典裏,而後取就很方便了；

In [298]: list1 = ['name', 'age']
In [300]: list2 = ['tom','20']
In [301]: list3 = ['mike','25']

In [302]: list2
Out[302]: ['tom', '20']

In [303]: zip(list1, list2)
Out[303]: [('name', 'tom'), ('age', '20')]
In [304]: list1
Out[304]: ['name', 'age']
In [305]: list2
Out[305]: ['tom', '20']

In [306]: zip(list1, list3)
Out[306]: [('name', 'mike'), ('age', '25')]

註釋：zip函數會把兩個列表合併,組成一個大的列表；

註釋：列表 [ ] 元組 ( ) 字典 { } 字符串 ' '

字典的方法：

keys()

values()

items()

建立字典； dic { }

dic = {'a':1, 1:123} a 表示key 鍵值 1 表是 value 中間用冒號：隔開；

In [307]: dic = {}

In [308]: type(dic)
Out[308]: dict

In [309]: dic = {'a':1, 1:123}           #建立兩對數據; key - value 對應;

In [310]: dic
Out[310]: {1: 123, 'a': 1}

二、那麼用元組()做爲key值來建立字典；以下；由於元組()是不可變的,能夠用來當作key 鍵值； dc = {('a','b'):'hello'}

In [313]: dc = {('a','b'):'hello'}

In [314]: type(dc)
Out[314]: dict

In [315]: dc
Out[315]: {('a', 'b'): 'hello'}

三、那麼用list[]來做爲key 值建立字典,不能夠的,由於list是可變的；

In [317]: dc1 = {[1]:1}
------------------------------------------------------------
TypeError                  Traceback (most recent call last)
<ipython-input-317-c906c08b610a> in <module>()
----> 1 dc1 = {[1]:1}

TypeError: unhashable type: 'list'

註釋：如上圖例,全部list[ ] 不能當作字典的鍵值 key 來使用；

len(dic) 也能夠看字典的長度；

四、字典的參數以下；

dic.key() 返回全部key值組成一個列表list並顯示；

In [319]: dic.keys()
Out[319]: ['a', 1, ('a', 'b')]

dic.values() 返回全部value值組成一個列表list並顯示；

In [320]: dic.values()
Out[320]: [1, 123, 'hello']

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

(一) pyhon 基礎語法(數值 字符串 元組 列表 字典)

(一) pyhon 基礎語法(數值字符串元組列表字典)