Python学习笔记[2]

1. 常见的数据类型
2. 字符串的常用操作
3. 列表的语法和使用
4. 元组的语法和使用
5. 字典的语法和使用

常见的数据类型

Python中的数据类型可以分为两类，一类是 基本数据类型 一类是 引用数据类型

基本数据类型

• 字符型： 'a', 'message'
• 数值型： 59, 1991.59
• 布尔类型: True, False

引用数据类型

• 列表： [1, 2, 3], ['abc', 'xyz']
• 元组： (1, 2, 3), ('abc', 'xyz')
• 字典： {'name'='larry', 'age': 25}
• 类

基本数据类型与引用数据类型的区别：前者传值，后者传址

字符串的常用操作

• 移除字符串的两端空白字符

In [12]: a = '   aa   '

In [13]: a
Out[13]: '   aa   '

In [14]: a.strip()
Out[14]: 'aa'

In [15]: a.lstrip()
Out[15]: 'aa   '

In [16]: a.rstrip()
Out[16]: '   aa'

• 将字符串以指定的分割符分割成列表

In [17]: a = 'a,b,c,d,e'

In [18]: a.split(',')
Out[18]: ['a', 'b', 'c', 'd', 'e']

• 统计字符串长度

In [19]: a = 'I am Chinese!'

In [20]: len(a)
Out[20]: 13

• 在字符串中找到指定字符的位置

In [21]: a = 'polarsnow'

In [22]: a.index('o')
Out[22]: 1

In [23]: a.index('o', 2)
Out[23]: 7

In [24]: a.index('o', 2, 6)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-24-2bb3a06d2fe6> in <module>()
----> 1 a.index('o', 2, 6)

ValueError: substring not found

• 切片

In [25]: a = 'polarsnow'

In [26]: a[0:5]
Out[26]: 'polar'

In [27]: a[:5] 
Out[27]: 'polar'

In [28]: a[-1]
Out[28]: 'w'

In [29]: a[-4:]
Out[29]: 'snow'

In [30]: a[5:] 
Out[30]: 'snow'

In [31]: a[-4:-1]  #注意Python中的切片是左闭右开
Out[31]: 'sno'

• 统计字符串中指定字符的个数

In [32]: a = 'polarsnow'   

In [33]: a.count('o')
Out[33]: 2

• 将指定字符串置于*

In [34]: a = 'polarsnow'

In [35]: a.center(50, '-')
Out[35]: '--------------------polarsnow---------------------'

• 判断是否以指定字符串开头或结尾

In [38]: a = 'polarsnow'  

In [39]: a.endswith('ow')
Out[39]: True

In [40]: a.startswith('po')
Out[40]: True

• 字符串大小写或首字母大写

In [41]: a = 'polarsnow'   

In [42]: a.upper()
Out[42]: 'POLARSNOW'

In [43]: a.upper().lower()
Out[43]: 'polarsnow'

In [44]: a.capitalize()
Out[44]: 'Polarsnow'

• 字符串属性判断-isalnum-是否只含有字母和数字

In [46]: a = 'polarsnow'

In [47]: a.isalnum()    
Out[47]: True

In [48]: a = 'polarsnow%'

In [49]: a.isalnum()     
Out[49]: False

In [50]: a = 'polarsnow5'

In [51]: a.isalnum()     
Out[51]: True

In [52]: a = 'polar snow'

In [53]: a.isalnum()     
Out[53]: False

• 字符串属性判断-isalpha-是否只含有字母

In [54]: a = 'polarsnow' 

In [55]: a.isalpha()
Out[55]: True

In [56]: a = 'polarsnow%'

In [57]: a.isalpha()     
Out[57]: False

In [58]: a = 'polarsnow5'

In [59]: a.isalpha()     
Out[59]: False

In [60]: a = 'polar snow'

In [61]: a.isalpha()     
Out[61]: False

• 字符串属性判断-isdigit-是否只包含数字

In [62]: a = '123'

In [63]: a.isdigit()
Out[63]: True
``

- 字符串属性判断-isspace-是否只包含空格

​```python
In [71]: a = ' '

In [72]: a.isspace()
Out[72]: True

In [73]: a = ''     

In [74]: a.isspace()
Out[74]: False

• 字符串其他属性判断

str.isupper()  #检查字符串所有的字母是否全部为大写
str.islower()  #检查字符串的所有字母是否全部为小写
str.istitle()  #检查字符串的所有单词拼写是否首字母大写，其余小写

• 字符串拼接可迭代对象

l = [1, 2, 3, 4, 5]
print("".join(l))

------------
Traceback (most recent call last):
  File "/Users/lvrui/PycharmProjects/untitled/4/test.py", line 2, in <module>
    print("".join(l))
TypeError: sequence item 0: expected str instance, int found

使用join的方式把一个可迭代对象进行拼接的基本要求是，可迭代对象中的每一个元素必须是字符串！！！

l = ['1', '2', '3', '4', '5']
print("+".join(l))

------------
1+2+3+4+5

列表的常用操作

• 列表的定义

list_a = []  #定义了一个空列表
list_b = [1, 'a', [2, 'z']]  #嵌套列表

• 列表的索引/取值

In [75]: a = ['a', 'b', 'c', 'a', 'd']

In [76]: a[0]
Out[76]: 'a'

In [77]: a[1]
Out[77]: 'b'

• 列表的切片

In [78]: a = ['a', 'b', 'c', 'a', 'd']

In [79]: a[2:]
Out[79]: ['c', 'a', 'd']

In [80]: a[-1]
Out[80]: 'd'

In [81]: a[-2:]  
Out[81]: ['a', 'd']

In [82]: a[1:3]
Out[82]: ['b', 'c']  #与字符串的切片相同，也要注意左闭右开

In [128]: a = ['a', 'b', 'c', 'a', 'd']

In [129]: a[::2]  #设置步长
Out[129]: ['a', 'c', 'd']

• 列表的遍历

In [83]: a = ['a', 'b', 'c', 'a', 'd']

In [84]: for item in a:
   ....:     print item
   ....:     
a
b
c
a
d

• 向列表中追加数据

In [85]: a = ['a', 'b', 'c', 'a', 'd']

In [86]: a.append('xxx')

In [87]: a
Out[87]: ['a', 'b', 'c', 'a', 'd', 'xxx']

• 向列表中插入数据

In [107]: a = ['a', 'b', 'c', 'a', 'd']

In [108]: a.insert(0, 'xxx')

In [109]: a
Out[109]: ['xxx', 'a', 'b', 'c', 'a', 'd']

• 删除列表中的元素

In [88]: a = ['a', 'b', 'c', 'a', 'd']

In [89]: del a[0]  #万能删除法 可以将整个变量删除

In [90]: a
Out[90]: ['b', 'c', 'a', 'd']

In [91]: a.pop()  #将列表最后一个元素删除
Out[91]: 'd'

In [92]: a
Out[92]: ['b', 'c', 'a']

In [93]: a.remove('c')  #删除列表中，第一次出现的指定元素（即使有两个c，只会删除第一个）

In [94]: a
Out[94]: ['b', 'a']

In [95]: a = ['a', 'b', 'c', 'a', 'd']  #重新赋值

In [96]: a
Out[96]: ['a', 'b', 'c', 'a', 'd']

In [97]: del a[1:4]  #删除连续的元素 注意左闭右开

In [98]: a
Out[98]: ['a', 'd']

• 修改列表中的元素

In [101]: a = ['a', 'b', 'c', 'a', 'd']

In [102]: a[3] = 'd'

In [103]: a[4] = 'e'

In [104]: a
Out[104]: ['a', 'b', 'c', 'd', 'e']

• 列表的长度

In [105]: a = ['a', 'b', 'c', 'a', 'd']

In [106]: len(a)
Out[106]: 5  #长度为5 注意索引只到4

• 统计列表中指定元素的个数

In [110]: a = ['a', 'b', 'c', 'a', 'd']

In [111]: a.count('a')
Out[111]: 2

• 将列表中的元素顺序反转

In [112]: a = ['a', 'b', 'c', 'a', 'd']

In [113]: a.reverse()

In [114]: a
Out[114]: ['d', 'a', 'c', 'b', 'a']

• 排序（根据ascii码）

In [115]: a = ['a', 'b', 'c', 'a', 'd']

In [116]: a.sort()

In [117]: a
Out[117]: ['a', 'a', 'b', 'c', 'd']

• 列表的扩展

In [120]: a = ['a', 'b', 'c', 'a', 'd']

In [121]: b = ['xxx', 'yyy']

In [122]: a.extend(b)

In [123]: a
Out[123]: ['a', 'b', 'c', 'a', 'd', 'xxx', 'yyy']

元组的语法和使用（元组就是不可变的列表）

元组中不可增，删，改。在取值的时候与列表操作类似，有以下常用方法

• tuple.count(): 统计指定元素的个数

• tuple.index(): 找到指定元素的索引

字典的语法和使用

• 字典的定义

In [132]: a = {}  #定义了一个空字典

In [133]: a = {'a':1, 'b':2, 'c':3}

• 字典中增加元素/修改元素

#字典是不重复且无序的，增加元素的操作和修改类似，如果元素存在即修改，如果元素不存在即添加

In [133]: a = {'a':1, 'b':2, 'c':3}

In [134]: a['d'] = 4

In [135]: a
Out[135]: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

In [136]: a['d'] = 59

In [137]: a
Out[137]: {'a': 1, 'b': 2, 'c': 3, 'd': 59}

• 删除字典中的元素

In [140]: a = {'a':1, 'b':2, 'c':3}

In [141]: a.pop('b')  #因为字典是无序的 与列表中的pop删除最后一个元素的概念区分开 这里需要指定“键”
Out[141]: 2

In [142]: a
Out[142]: {'a': 1, 'c': 3}

In [143]: del a['a']  #万能删除依然好用~~~

In [144]: a
Out[144]: {'c': 3}

• 指定key取值

In [145]: a = {'a':1, 'b':2, 'c':3}

In [146]: a['a']
Out[146]: 1

In [147]: a['d']  #这种取值的方法如果没有找到，则报错
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-147-0b64a016a51f> in <module>()
----> 1 a['d']

KeyError: 'd'

In [148]: a.get('d')  #使用get如果没有找到，则返回None

In [149]: 

In [162]: 'a' in a  #使用万能的in语法
Out[162]: True

• 查找所有的"键"和所有的“值”

In [150]: a = {'a':1, 'b':2, 'c':3}

In [151]: a.keys()
Out[151]: ['a', 'c', 'b']

In [152]: a.values()
Out[152]: [1, 3, 2]

In [153]: a = {'a':1, 'b':2, 'c':3}

In [154]: a.items()
Out[154]: [('a', 1), ('c', 3), ('b', 2)]

In [155]: for k,v in a.items():  #执行效率低下（有dict2list的转换过程），数据量大不推荐使用
   .....:     print('key: ', k, 'value: ', v)
   .....:     
('key: ', 'a', 'value: ', 1)
('key: ', 'c', 'value: ', 3)
('key: ', 'b', 'value: ', 2)

In [170]: for key in a:  #高效的字典遍历方法
   .....:     print(key, a[key])
   .....:     
('a', 1)
('c', 3)
('b', 2)

• 使用子列表更新主列表中的元素（覆盖）

In [157]: a
Out[157]: {'a': 1, 'b': 2, 'c': 3}

In [158]: b = {'c': 59}

In [159]: a.update(b)

In [160]: a
Out[160]: {'a': 1, 'b': 2, 'c': 59}

• dict.setdefault(k,v)

#根据k去取值，如果有则返回v，如果没有则添加这个元素
In [164]: a = {'a':1, 'b':2, 'c':3}

In [165]: a.setdefault('a')
Out[165]: 1

In [166]: a.setdefault('a', 59)
Out[166]: 1

In [167]: a.setdefault('d', 59) 
Out[167]: 59

In [168]: a
Out[168]: {'a': 1, 'b': 2, 'c': 3, 'd': 59}