01: Python基本数据类型

1.1 列表和元组返回顶部

1、列表基本操作

1. 列表赋值　

a = [1,2,3,4,5,6,7,8]

a[0] = 100                                #the result ： [100, 2, 3, 4, 5, 6, 7, 8]

2. 元素删除

a = [1,2,3,4,5,6,7,8]

del a[0]　　                               #the result ： [2, 3, 4, 5, 6, 7, 8]

3. 分片赋值

a = [1,2,3,4,5,6,7,8]

a[::2]                                   # [1, 3, 5, 7]

a[-2:]                                   # [7, 8]

a[1:1] = [0,0,0]                         # the result : [1, 0, 0, 0, 2, 3, 4, 5, 6, 7, 8]

4. 使用 for i in range(10,-1,-1) 生成列表

for i in range(10,-1,-1): # 开始位置（10），结束位置（-1）， 步长（-1）

    print i,

# 打印结果：10 9 8 7 6 5 4 3 2 1 0

# 从10开始，每次向后取一个值，直到遇到结束位置 -1

2、列表方法

1. append

　　作用：append用于在列表末尾追加新的对象

a = [1,2,3]

a.append(4)                    　　　　　　　#the result ： [1, 2, 3, 4]

2. count

　　作用：count方法统计某个元素在列表中出现的次数

a = ['aa','bb','cc','aa','aa']

print(a.count('aa'))                                    #the result ： 3

3. extend

　　作用：extend方法可以在列表的末尾一次性追加另一个序列中的多个值

a = [1,2,3]

b = [4,5,6]

a.extend(b)                    #the result ：[1, 2, 3, 4, 5, 6]

4. index

　　作用：index函数用于从列表中找出某个值第一个匹配项的索引位置

a = [1,2,3,1]

print(a.index(1))                                    #the result ： 0

5. insert

　　作用： insert方法用于将对象插入到列表中

a = [1,2,3]

a.insert(0,'aa')            #the result : ['aa', 1, 2, 3]

6. pop

　　作用：pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值

a = [1,2,3]

a.pop()                                                 #the result ： [1, 2]

a.pop(0)

7. remove

　　作用：remove方法用于移除列表中某个值的第一个匹配项

a = ['aa','bb','cc','aa']

a.remove('aa')                       #the result ： ['bb', 'cc', 'aa']

8. reverse

　　作用：reverse方法将列表中的元素反向存放

a = ['a','b','c']

a.reverse()                  #the result ： ['c', 'b', 'a']

9. sort

　　作用：sort方法用于在原位置对列表进行排序，意味着改变原来的列表，让其中的元素按一定顺序排列

a = ['a','b','c',1,2,3]

a.sort()                        #the result ：[1, 2, 3, 'a', 'b', 'c']

10. enumrate

li = [11,22,33]

for k,v in enumerate(li, 1):

    print(k,v)

11. range和xrange 指定范围，生成指定的数字

　　注：python3中的range类似python2中的xrange，比如a = range(1,4) : a返回的不是列表对象而是一个可迭代对象（<class 'range'>）

#1、range根据start与stop指定的范围以及step设定的步长，生成一个序列：range([start,] stop[, step])

#2、xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器

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

    print(i)

12. 列表去空

法1：

filter(None, your_list)

法2：

while '' in your_list:

    your_list.remove('')

法3：

your_list = [x for x in your_list if x != '']

3、元组

　　元组定义：元组和列表一样，也是一种序列，唯一的不同是元组不能修改。

1. 创建元组举例

#1. 创建元组

a = (1,2,3,4,5,6)

#2. 将列表转换成元组

tuple([1,2,3,4])                                    #the result ： (1, 2, 3, 4)

4、列表和元组常用函数

　　com(x,y) 比较两个值

　　len(seq) 返回序列的长度

　　list(seq) 把序列转换成列表

　　max(args) 返回序列或者参数集合中得最大值

　　min(args) 返回序列或者参数集合中的最小值

　　reversed(seq) 对序列进行反向迭代

　　sorted(seq) 返回已经排列的包含seq 所有元素的列表

　　tuple(seq) 把序列转换成元组

1.2 字符串返回顶部

1、字符串格式化

1. 使用百分号（%）字符串格式化

num = 100

print("%d to hex is %x" %(num, num))        #100 to hex is 64

print("%d to hex is %#x" %(num, num))       #100 to hex is 0x64

2. 使用format字符串格式化

#1. 位置参数

print("{0} is {1} years old".format("tom", 28))           #tom is 28 years old

print("{} is {} years old".format("tom", 28))             #tom is 28 years old

print("Hi, {0}! {0} is {1} years old".format("tom", 28)) #Hi, tom! tom is 28 years old

#2. 关键字参数

print("{name} is {age} years old".format(name = "tom", age = 28))    #tom is 28 years old

#3. 下标参数

li = ["tom", 28]

print("{0[0]} is {0[1]} years old".format(li))          #tom is 28 years old

2、字符串方法

1. find方法

　　作用：find方法可以在一个较长的字符串中查找子串，他返回子串所在位置的最左端索引，如果没有找到则返回-1

a = 'abcdefghijk'

print(a.find('abc'))                           #the result ： 0

print(a.find('abc',10,100))                    #the result ： 11  指定查找的起始和结束查找位置

2. join方法

　　作用：join方法是非常重要的字符串方法，他是split方法的逆方法，用来连接序列中的元素，并且需要被连接的元素都必须是字符串。

a = ['','','']

print('+'.join(a))                                    #the result ： 1+2+3

3. split方法

　　作用：这是一个非常重要的字符串，它是join的逆方法，用来将字符串分割成序列

print('1+2+3+4'.split('+'))                            #the result ： ['1', '2', '3', '4']

4. strip

　　作用：strip 方法返回去除首位空格（不包括内部）的字符串

print("   test   test    ".strip())                #the result ：“test   test”

5. replace

　　作用：replace方法返回某字符串所有匹配项均被替换之后得到字符串

print("This is a test".replace('is','is_test'))     #the result ： This_test is_test a test

6、首字母大写

>>> s = 'aBdkndfkFFD'

>>> s.capitalize()

'Abdkndfkffd'

7、Pinyin 模块，将汉字转换成拼音

#! /usr/bin/env python

# -*- coding: utf-8 -*-

from xpinyin import Pinyin

while True:

    p = Pinyin()

    fullname = raw_input('name：').strip()

    fullname = fullname.decode('utf8')

    print fullname

    xin = fullname[0]

    ming = fullname[1:]

    name = ming + '.' + xin

    username = p.get_pinyin(name, '')

    print username

    print username + '@yiducloud.cn'

汉字转拼音

1.3 字典返回顶部

1、字典基本使用

　　I. 键类型：字典的键不一定为整形数据，键可以是任意的不可变类型，比如浮点型（实行），字符串或者元组。
　　II．自动添加：即使键起初在字典中不存在，也可以为他赋值，这样字典就会建立新的项。而（在不适用append方法或者其他类似操作的情况下）不能将值关联到列表之外的索引上。

phonebook = {'Tom':8777,'Jack':9999,'Fly':6666}

print("Tom's Phonenumber is %(Tom)s" % phonebook)       #Tom's Phonenumber is 8777

2、字典常用方法

1. clear

　　作用：clear方法清除字典中所有的项，这是一个原地操作，所以无返回值（或则说返回None）

d = {}

d['Tom']=8777

d['Jack']=9999

print(d)                                #the result : {'Jack': 9999, 'Tom': 8777}

d.clear()

print(d)                                #the result : {}

2. copy

　　作用：copy方法返回一个具有相同 ”键-值” 对的新字典，而不是副本

d = {'Tom':8777,'Fly':6666}

a = d.copy()

a['Tom'] = '改变后的值'

print(d)                        #{'Fly': 6666, 'Tom': 8777}

print(a)                        #{'Fly': 6666, 'Tom': '改变后的值'}

3. fromkeys

　　作用：fromkeys方法使用给定的键建立新的字典，每个键都对应一个默认的值None。

　　首先建造一个空字典，然后调用它的fromkeys方法，建立另一个字典

print({}.fromkeys(['name','age']))         #the result　：　{'age': None, 'name': None}

4. get

　　作用：get方法是个更宽松的访问字典项的方法，如果试图访问字典中不存在的项时不会报错仅会返回：None

d = {'Tom':8777,'Jack':8888,'Fly':6666}

print(d.get('Tom'))                                #the result ：     8777

print(d.get('not_exist'))                          #the result ：     None

5. for循环字典的三种方法

d = {'Tom':8777,'Jack':8888,'Fly':6666}

for k,v in d.items():

    print(k,v)

for k in d.values():

    print(k)

for k in d.keys():

    print(k)

d = {'Tom':8777,'Jack':8888,'Fly':6666}

for k in list(d.keys()):

    print(k)

    if k == 'Tom':

        del d[k]

print(d)             # {'Fly': 6666, 'Jack': 8888}

for循环的同时删除字典中元素的方法

6. pop

　　作用：pop方法用于获得对应与给定键的值，然后将这个”键-值”对从字典中移除

d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v)                    #8777

7. popitem

　　① popitem方法类似于list.pop，list.pop会弹出列表的最后一个元素，但是popitem仅仅会弹出随机的项，因为字典没有”最后的元素”或则其他有关顺序的概念
　　② 所以想一个接一个的移除并处理字典中的项，popitem是非常有效的（因为不用获取键的列表）
　　③ 尽管popitem和列表的pop方法很类似，但是字典中没有与append等价的方法，因为字典是无序的，类似于append得方法是没有任何意义的

d = {'Tom':8777,'Jack':8888,'Fly':6666}

d.popitem()

8. setdefault

　　作用：setdefault方法在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdefault还能在字典中不含有给定键的情况下设定相应的键值

d = {'Tom':8777,'Jack':8888,'Fly':6666}

d.setdefault('Tom')                            #the result ： 8777

print(d.setdefault('Test'))                    #the result ： None

print(d)                                    #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}

9. update

　　作用：update方法可以利用一个字典项更新另一个字典，提供的字典中的项会被添加到旧的字典中，如有相同的键则会被覆盖

d = {'Tom':8777,'Jack':8888,'Fly':6666}

a = {'Tom':110,'Test':119}

d.update(a)

print(d)                        #the result ：{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}

10. 将两个列表组合成字典

keys = ['a', 'b']

values = [1, 2]

#1、zip生成字典

print(dict(zip(keys,values)))                                      # {'a': 1, 'b': 2}

#2、for循环推倒字典

print({keys[i]: values[i] for i in range(len(keys))})              # {'a': 1, 'b': 2}

1.4 集合返回顶部

1、集合作用　

　　1. 去重
　　2．取两个列表的交集
　　3. 取两个列表的并集

list_1 = [1,2,3,4,5,1,2]

#1、去重(去除list_1中重复元素1,2)

list_1 = set(list_1)                                    #去重： {1, 2, 3, 4, 5}

print(list_1)

list_2 = set([4,5,6,7,8])

#2、交集（在list_1和list_2中都有的元素4,5）

print(list_1.intersection(list_2))                      #交集： {4, 5}

#3、并集（在list_1和list_2中的元素全部打印出来，重复元素仅打印一次）

print(list_1.union(list_2))                             #并集： {1, 2, 3, 4, 5, 6, 7, 8}

#4、差集

print(list_1.difference(list_2))                        #差集：在list_1中有在list_2中没有：   {1, 2, 3}

print(list_2.difference(list_1))                        #差集：在list_1中有在list_2中没有：   {8, 6, 7}

#5、子集

print(list_1.issubset(list_2))                          #子集：    False    List_1中的元素是否全部在list2中

#6、父集

print(list_1.issuperset(list_2))                        #父集：    False    List_1中是否包含list_2中的所有元素

#7、交集

print(list_1 & list_2)                                  #交集    {4, 5}

#8、union并集

print(list_1 | list_2)                                  #并集：  {1, 2, 3, 4, 5, 6, 7, 8}

#9、difference差集

print(list_1 - list_2)                                  #差集：    {1, 2, 3}

#10、在集合中添加一个元素999

list_1.add(999)

print(list_1)                                           #Add()方法：          {1, 2, 3, 4, 5, 999}

#11、删除集合中任意一个元素不会打印删除的值

list_1.pop()                                            #Pop()方法：            无返回值

#12、discard删除集合中的指定元素，如过没有则返回None

print(list_1.discard("ddd"))                            #Discard()方法：   删除指定的值，没有返回None

集合常用方法