python的学习笔记01_4基础数据类型列表 元组 字典 集合 其他其他（for，enumerate，range)

列表

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素
　　特性：
　　　　1.可存放多个值
　　　　2.可修改指定索引位置对应的值，可变
　　　　3.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

、创建列表 只要把逗号分隔的不同数据项，使用方括号[],括起来即可，　　下标（角标索引）从0开始，最后一个一个元素下标可以写-1

list = ['1' , '2' , '3']

list = [] 空列表

二、增:

name.insert(2,"wenqiang")　　#列表name的索引为2的位置添加一个元素 wenqiang

name.append(“01”)　　　　　#列表name的末尾，添加一个元素“01”　

name.append([1,2,3,4])　　　#列表name的末尾，添加一个列表

name.extend('abcde')　　　　#列表name的末尾，迭代的增加多个元素

迭代着增加：就是数据类型的最小组成单位作为列表的一个元素进行增加

三、删:

name.pop()　　#按照下标进行删除，默认删除最后一个（有返回值）

name.remove()　　#remove()直接在字符串中查找括号内的元素，并删除

name.clear()　　#清空列表，使列表变成一个空的

del name　　#直接删除内存文件，导致name这个列表不存在

四、改:

name[0] = "x"　　#通过对索引位置重新赋值，达到更改元素内容的目的

name[0:2] = ["1" , "2" , "3"]　　#更改可切片

五、查:

name = [1,2,3,4,5,6]

print(name[0])　　#通过下表进行查找元素

name.index(“2”)　　#通过index 查找元素2 在列表name中的位置下标

六、排序和反转:

name.sort()　　　　　　　#正向排序

name.sort(reverse = True)　　#反向排序

name.reverse　　#反转

七、列表操作函数:

name = [1,2,3,1,23,1,2]

1.name.count("1")　　#计数，通过count统计列表name中，元素 1 出现的次数

2.len(name)　　#列表元素个数

3.max(list)　　　　#返回列表元素最大值

4.min(list)　　　　#返回列表元素最小值

5.list(seq) 　　　　#将元组seq强制转换成列表

6. enumerate()　　　　#打印元素对应的下标

八，list 循环和切片

1，循环

for i in list:

print i

如果直接for 循环一个list 的时候，那么每次循环的值都是这个list 里面的元素

2，切片（list 取值的一种方法）

name[n:m]  切片是不包含后面那个元素的值（顾头不顾尾）

name[:m] 如果切片前面一个值缺省的话，从开头开始取

name[n:] 如果切片后面的值缺省的话，取到末尾

name[:] 如果全部缺省，取全部

name[n:m：s] s：步长  隔多少个元素取一次

步长是正数，从左往右取

步长是负数，从右往左取

注：切片同样适用于字符串，字符串也有下标

九、列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

实例1：要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))：list = list(range(1,11))

实例2：生成[1x1, 2x2, 3x3, ..., 10x10]可以用  list = list(x * x for x in range(1,11))
实例3：for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：list = list(x * x for x in range(1,11) if x%2== 0)
实例4：使用两层循环，可以生成全排列：
list = [m + n for m in 'ABC' for n in 'XYZ']
print(list)
输出结果：['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
实例5：for循环其实可以同时使用两个甚至多个变量，比如dict的items()可以同时迭代key和value：
法一：
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> for k, v in d.items():
...     print(k, '=', v)
...
y = B
x = A
z = C
法二：
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

元组

定义：与列表类似，只不过［］改成（）

　　特性：

　　　　1.可存放多个值
　　　　2.不可变
　　　　3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元祖的创建

　　ages = (11, 22, 33, 44, 55)
　　或
　　ages = tuple((11, 22, 33, 44, 55))
　　顺序及下标图示

元祖的常用操作

　　索引

　　切片　　

　　循环

　　长度

　　包含

元祖的特性详解

　　1.可存放多个值

　　　　如果元祖中只有一个值

t = (1,)
t = (1)   #<==>t = 1

　　　　元祖中不仅可以存放数字、字符串，还可以存放更加复杂的数据类型

　　2.不可变

　　　　元祖本身不可变，如果元祖中还包含其他可变元素，这些可变元素可以改变

元祖相关知识拾遗

　　字典中遇到的tuple

　　1.字典的定义

　　　　元祖可以作为字典的key：

dic = {('alex','male'):'v1',('wusir','male'):'v2'}
print(dic)

　　　　字典定义可以用到元祖：

person = dict((['name','苑昊'],['文周',18]))
person = dict((('name','苑昊'),('文周',18)))
print(person)

　　2.字典的items方法，将字典中的每一项作为元祖返回

dic = {'k1':'v1','k2':'v2'}
print(dic.items())
#dict_items([('k1', 'v1'), ('k2', 'v2')])

　　　　再讲循环

dic = {'key1':'value1','key2':'value2'}
for key,value in dic.items():
    print(key,value)

字典

字典是Python语言中唯一的映射类型。

　　定义：｛key1:value1,key2:value2｝

　　　　    1、键与值用冒号“：”分开；
　　　　    2、项与项用逗号“，”分开；
　　特性：

　　　　　 1.key-value结构

　　　　    2.key必须可hash、且必须为不可变数据类型、必须唯一

　　　　    3.可存放任意多个值、可修改、可以不唯一

　　　　    4.无序

字典的创建

　　person = {"name": "alex", 'age': 20}
　　或
　　person = dict(name='seven', age=20)
　　person = dict({"name": "egon", 'age': 20})
　　person = dict((['name','苑昊'],['文周',18]))
　　{}.fromkeys(seq,100) #不指定100默认为None

　　注意：

>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]} 

字典的常用操作

键、值、键值对

　　　　1、dic.keys() 返回一个包含字典所有KEY的列表；
　　　　2、dic.values() 返回一个包含字典所有value的列表；
　　　　3、dic.items() 返回一个包含所有（键，值）元祖的列表；
　　　　4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；

　　新增

　　　　1、dic['new_key'] = 'new_value'　

　　　　2、dic.setdefault(key, None) ,如果字典中不存在Key键，由 dic[key] = default 为它赋值；

　　删除

　　　　1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；

　　　　2、dic.clear() 删除字典中的所有项或元素；

　　修改

　　　　1、dic['key'] = 'new_value',如果key在字典中存在，'new_value'将会替代原来的value值。

　　　　2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中。

　　查看

　　　　1、dic['key']，返回字典中key对应的值，若key不存在字典中，则报错；

　　　　2、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；　　　

　　len(dict):　　计算字典元素个数，即键的总数。

　　str(dict):　　输出字典可打印的字符串。

　　type(variable):　　返回输入的变量类型，如果变量是字典就返回字典类型。

　　# 通过一行语句创建一个这样的字典{1: 'alex', 2: 'alex', 3: 'alex'}？

　　# 不能直接写 dic={1:'alex',2:'alex',3: 'alex'})

t = dict.fromkeys((1,2,3),'alex')

print(t)

集合

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：

　　去重，把一个列表变成集合，就自动去重了。

　　关系测试，测试两组数据之前的交集、差集、并集等关系。

1，集合的创建。

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2)  # {1, 2, 'barry'} {1, 2, 'barry'}

2，集合的增。

set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)

#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)

3，集合的删。

set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

4，集合的其他操作：

　　4.1 交集。（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

　　4.2 并集。（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7,8}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7,8}

　　4.3 差集。（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

　　4.4反交集。 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

　　4.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

5，frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

三，基础数据类型的总结

按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组，布尔值

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

四，其他（for，enumerate，range）。

for循环：用户按照顺序循环可迭代对象的内容。

msg = '老男孩python是全国范围内最好的python培训机构'
for item in msg:
    print(item)

li = ['alex','银角','女神','egon','太白']
for i in li:
    print(i)

dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
    print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　　　　

 

range：指定范围，生成指定数字。

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)