基本数据类型

字符串处理

字符串拼接

# coding=utf-8
# 将姓氏和名字分别保存在两个变量中
first_name = '11'
last_name = '22'
# 将姓氏和名字拼接，将结果存储在full_name变量中
full_name = first_name + " " + last_name
print(full_name)

得到的结果是：11 22

字符转换

len()函数来计算，并返回字符串的长度，即字符串中单个元素的个数

# 创建一个字符串变量，获取其长度并打印出来
color = 'It is red'
length = len(color)
print (length)
# 直接在len函数中引入字符串内容获得其长度，然后打印出来
print(len('This is a circle!'))

（空格也占一个字符元素的位置）

得到的结果是：
9
17

upper()，将字符串中的所有字符都转换为大写
lower()，将字符串中的所有字符转换为小写
title()方法，将字符串所有单词的首字母变成大写

# 创建一个字符串say_hello
say_hello = 'Dear my Daughter'
# 使用upper()方法对say_hello字符串进行处理
upper_say_hello = say_hello.upper()
# 使用lower()方法对say_hello字符串进行处理
lower_say_hello = say_hello.lower()
# 使用title()方法对say_hello字符串进行处理
title_say_hello = say_hello.title()
# 打印输出四个字符串
print (say_hello+"\n")
print (upper_say_hello+"\n")
print (lower_say_hello+"\n")
print (title_say_hello+"\n")

（不会对原始的 say_hello字符串产生影响，转换后的字符串会存入新的变量中。）

得到的结果是：
Dear my Daughter
DEAR MY DAUGHTER
dear my daughter
Dear My Daughter

strip()，去除字符串首尾空格或指定字符

# 创建一个字符串hello_world
hello_world = '  **The world ** is big!*    '
# 利用strip()方法处理hello_world字符串
blank_hello_world = hello_world.strip()
char_hello_world = hello_world.strip('TH *')
# 打印输出转换后的字符串
print(blank_hello_world)
print(char_hello_world)

得到的结果是：
**The world ** is big!*
he world ** is big!

字符串查找与替换

find()，字符串查找方法
返回值为第一个子串所在位置的最左端索引，若没有找到符合条件的子串，则返回-1

# 创建一个字符串
source_string = 'The past is gone and static'
# 查看"past"在source_string字符串中的位置
print(source_string.find('past'))
# 查看"love"在source_string字符串中的位置
print(source_string.find('love'))

得到的结果是：
4
-1

replace()，用以替换给定字符串中的子串

# 创建一个字符串circle
source_string = 'The world is big'
# 利用replace()方法用子串"small"代替子串"big"
print(source_string.replace('big','small'))

得到的结果是：
The world is small

split()方法实现字符串分割
如果不提供分隔符，则程序会默认把空格（制表、换行等）作为分隔符。

# 待处理字符串source_string
source_string = '1+2+3+4+5'
# 利用split()方法，按照`+`和`/`对source_string字符串进行分割
print(source_string.split('+'))
print(source_string.split('/'))

得到的结果是：
['1', '2', '3', '4', '5']
['1+2+3+4+5']

玩转列表

列表元素的增删改

append()，在列表尾部添加元素

# 初始化guests列表
guests=['Zhang san','Li si','Wang wu','Zhao liu']
# 向guests列表尾部追加一个名为Hu qi的客人
guests.append('Hu qi')
# 输出新的guests列表
print(guests)

得到的结果是：
['Zhang san','Li si','Wang wu','Zhao liu','Hu qi']

insert()，在列表指定位置添加元素

# 创建并初始化guests列表
guests=['Zhang san','Li si','Wang wu','Zhao liu']
# 向guests列表Zhang san后面增加一个名为Hu qi的客人
guests.insert(1,'Hu qi')
# 输出新的guests列表
print(guests)

得到的结果是：
['Zhang san','Hu qi','Li si','Wang wu','Zhao liu']

修改列表元素

# 初始化guests列表
guests=['Zhang san','Li si','Wang wu','Zhao liu']
# 将列表中的`Wang wu`改为`Wang shi`
guests[2] = 'Wang shi'
# 输出新的guests列表
print(guests)

得到的结果是：
['Zhang san','Li si','Wang shi','Zhao liu']

del方法删除指定位置的元素
该操作将从源列表删除对应元素。

# 初始化guests列表
guests=['Zhang san','Li si','Wang wu','Zhao liu']
# 将列表中的`Zhang san`删除
del guests[0]
# 输出新的guests列表
print(guests)

得到的结果是：
['Li si','Wang wu','Zhao liu']

pop方法删除指定位置的元素
该方法将从源列表删除对应元素，同时返回被删除的元素。

# 初始化guests列表
guests=['Zhang san','Li si','Wang wu','Zhao liu']
# 将列表中的`Zhang san`删除
deleted_obj = guests.pop(0)
# 输出被删除的元素以及删除后的guests列表
print(deleted_obj)
print(guests)

得到的结果是：
Zhang san
['Li si','Wang wu','Zhao liu']

remove()，删除指定的元素
如果列表中有多个值为obj的元素，remove仅删除位置索引最靠前的那个元素。

# 初始化guests列表
# 初始化guests列表，列表中有多个名为Zhang san的客人
guests=['Zhang san','Li si','Wang wu','Zhao liu','Zhang san']
# 将列表中的`Zhang san`删除
guests.remove('Zhang san')
# 输出新的guests列表
print(guests)

得到的结果是：
['Li si','Wang wu','Zhao liu','Zhang san']

列表元素的排序

sort()，实现对列表元素的排序功能
source_list.sort(reverse=True)
sort函数的可选参数。如果设置其值为True，则进行反向从大到小排序，如果设置为False或者不填写该参数，则默认进行正向从小到大排序。
sort函数会直接作用于待排序的列表并修改其排序

guests = ['zhang san','li si','wang wu','sun qi','qian ba']
guests.sort()
print(guests)
guests.sort(reverse=True)
print(guests)

得到的结果是：
['li si','qian ba','sun qi','wang wu','zhang san']
['zhang san','wang wu','sun qi','qian ba','li si']

数值列表

range()，生成一系列连续增加的数字
range(lower_limit,upper_limit,step)
大于等于下限，小于上限，默认步长为1

for i in range(1,6,2):
    print(i)

得到的结果是：
1
3
5

基于range()函数创建数字列表

# 声明一个列表变量
numbers = []
# 利用append()函数和range()函数向列表插入目标元素
for i in range(10):
    number = i**2
    numbers.append(number)
print(numbers)

得到的结果是：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

使用list()函数和range()函数创建数字列表
利用list()函数将range()生成的系列数字直接转为列表

data_list = list(range(1,6))
print(data_list)

得到的结果是：
[1,2,3,4,5]

对数字列表进行简单的统计运算
min：数字列表求最小值的语法关键字；
max：数字列表求最大值的语法关键字；
sum：数字列表求和的语法关键字。

numbers = [2,4,11,1,21,32,5,8]
print('The min number is',min(numbers))
print('The max number is',max(numbers))
print('The sum is',sum(numbers))

得到的结果是：
The min number is 1
The max number is 32
The sum is 84

列表切片

list_slice = source_list[start🔚step]

source_list：被切片的源列表；
list_slice：切片后生成的子序列列表；
start：切片起始索引位置，省略则从头开始；
end：切片结束索引位置，省略则切至列表末尾；
step：切片步长，可选参数，表示每N个元素取一个，默认为1。

注意：切片和range()函数一样，Python 会自动到达所指定切片结束索引位置的前面一个元素停止。

my_menu = ['fish','pork','pizza','carrot']
print(my_menu[1:4:2])
print(my_menu[:3])
print(my_menu[2:])

得到的结果是：
['pork','carrot']
['fish','pork','pizza']
['pizza','carrot']

负数也可以

my_menu=['fish','pork','pizza','carrot']
print(my_menu[-3:])

得到的结果是：
['pork','pizza','carrot']

元组与字典

元组的使用

元组与列表很相似，两者之间的差别在于：
列表在初始化后其中的元素还可以进行增删改等操作，但是元组在初始化后其中的元素不能进行更改；
列表在赋值时使用方括号[]，而元组在赋值时使用小括号()。

创建元组

menu1 = ('meat','fish','chicken')
menu2 = ('meat',)

访问元组

menu = ('meat','fish','chicken','carrot')
print(menu[0])
print(menu[1:3])

得到的结果是：
meat
('fish', 'chicken')

元组内置函数
元组不能被修改

len(tuple)：计算元组中元素个数；

max(tuple)：返回元组中元素的最大值；

min(tuple)：返回元组中元素的最小值；

tuple(seq)：将列表转换为元组。

##字典的使用
字典：由键-值对，组成，只关注对应关系，不关注顺序
添加键值对

# 创建并初始化menu字典
menu = {'fish':40, 'pork':30, 'potato':15, 'noodles':10}
# 向menu字典中添加菜名和价格
menu['juice'] = 12
menu['egg'] = 5
# 输出新的menu
print(menu)

得到的结果是：
{'fish': 40,'pork': 30,'potato': 15,'noodles': 10, 'juice': 12,'egg': 5}

# 删除noodles键值对
del menu['noodles']

# 修改menu字典中菜fish的价格
menu['fish'] = 50

字典的遍历

遍历字典中的键-值对：items（）
遍历字典中的键：keys()
遍历字典中的值：values()

# coding = utf-8
# 创建并初始化menu菜单字典
menu={'fish':'40','pork':'30','potato':'20','lamb':'50'}
# 利用items()方法遍历输出键和值
for key,value in menu.items():
    print('\nkey:'+key)
    print('value:'+value)

得到的结果是：
key:fish
value:40
key:pork
value:30
key:potato
value:20
key:lamb
value:50

注：输出结果表示，items()方法每次都将对应的键和值指定到key和value变量中，然后用for循环输出。

嵌套

字典：键值对中，值泛指，可以是数据、列表、字典、字符
列表中存储字典

# 创建3个菜单字典，包含菜名和价格
menu1 = {'fish':40, 'pork':30, 'potato':20,'noodles':15}
menu2 = {'chicken':30, 'corn':55, 'lamb':65,'onion':12}
menu3 = {'bacon':36, 'beaf':48, 'crab':72,'eggs':7}
# 将3个菜单字典存储到列表menu_total中
menu_total = [menu1,menu2,menu3]
# 输出列表
print(menu_total)

得到的结果是：
[{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15}, {'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}, {'bacon': 36, 'beaf': 48, 'crab': 72, 'eggs': 7}]

字典中存储列表

# 初始化menu菜单，里面包含配料列表
menu = {'fish':['vinegar','soy','salt'], 'pork':['sugar','wine']}
# 输出pork这道菜的配料
print('The burding of pork is:',menu['pork'])

得到的结果是：
The burding of pork is: ['sugar', 'wine']

字典中存储字典

# 创建一个字典menu_sum，里面包含两个子菜单字典menu1和menu2
menu_sum = {
    'menu1':{'fish':40, 'pork':30, 'potato':20,'noodles':15},
    'menu2':{'chicken':30, 'corn':55, 'lamb':65,'onion':12}
}
# 输出menu1和menu2中的菜名和价格
print(menu_sum['menu1'])
print(menu_sum['menu2'])

得到的结果是：
{'fish': 40, 'pork': 30, 'potato': 20, 'noodles': 15}
{'chicken': 30, 'corn': 55, 'lamb': 65, 'onion': 12}

collections模块

命名元组

创建命名元组

collections.namedtuple("Point",["x","y"])
collections.namedtuple("Point","x y")
collections.namedtuple("Point","x,y")

Point = collections.namedtuple("Point","x,y")
p = collections.namedtuple("Point","x,y") #变量名不一定要和第一个参数相同

以上得到的变量Point或者p并不直接是一个元组对象，它只是一个类，如果要创建它的实例，则需要像创建类实例一样调用它：

p1 = Point(x = 0, y = 0)
p2 = p(x = 1, y = 1)

访问命名元组的元素

print(p1[0])
print(p1[1])

得到的结果是：
0
0

print(p2.x)
print(p2.y)

得到的结果是：
1
1

修改元素

p1 = p1._replace(x = 1) #将p1的x值从0换到1

计数器 (Counter)

计数器是一个无序容器，用于记录各种值出现的次数。它采用键值对的形式存储，要记录的值作为key，这个值出现的次数作为value，value值可正可负。
创建计数器

c = collections.Counter(['a','a','b','b','c']) #从list创建
c = collections.Counter(('a','a','b','b','c')) #从tuple创建
c = collections.Counter({'a':2,'b':2,'c':1}) #从dict创建
c = collections.Counter("aabbc") #从字符串创建
c = collections.Counter(a=2,b=2,c=1) #指定键值对

得到的结果是：
{'a': 2, 'b': 2, 'c': 1}

没有键时，不会异常，返回值为0.
增加与减少计数
除去字典使用的方法外，额外增加方法：

c.update("aabbcd") #字符串也是可迭代对象

上面这行语句执行后，c的值从原来的：
{'a': 2, 'b': 2, 'c': 1}
增加到了：
{'a': 4, 'b': 4, 'c': 2, 'd': 1}

c.subtract("aabbcd")

上面这行语句执行后，c的值从原来的：
{'a': 4, 'b': 4, 'c': 2, 'd': 1}
减少到了：
{'a': 2, 'b': 2, 'c': 1, 'd': 0}

删除元素

del(c['d'])

上面这行语句执行后，c的值从原来的：
{'a': 2, 'b': 2, 'c': 1, 'd': 0}
变成了：
{'a': 2, 'b': 2, 'c': 1}

TopN操作
获取出现次数最多的n个元素的成员函数most_common

top1 = c.most_common(1) #出现次数最多的元素
print(top1)
top2 = c.most_common(2) #出现次数最多的两个元素
print(top2)
all = c.most_common() #不提供参数则返回所有元素
print(all)

得到的结果是：
[('a', 2)]
[('a', 2), ('b', 2)]
[('a', 2), ('b', 2), ('c', 1)]

双向队列 (deque)

创建双向队列

d = collections.deque() #创建一个空队列
d = collections.deque(['a','b','c']) #从list创建
d = collections.deque(('a','b','c')) #从tuple创建
d = collections.deque({'a':0,'b':1,'c':2}) #从dict创建
d = collections.deque("abc") #从字符串创建

队列操作
右边操作

d.append('d') #向右边增加一个元素'd'
print(d)
d.pop() #从右边删除一个元素
print(d)

得到的结果：
deque(['a', 'b', 'c', 'd'])
deque(['a', 'b', 'c'])

左边操作

d.appendleft('+') #向左边增加一个元素'+'
print(d)
d.popleft() #从左边删除一个元素
print(d)

得到的结果：
deque(['+', 'a', 'b', 'c'])
deque(['a', 'b', 'c'])

可迭代对象的所有迭代值

d1 = collections.deque()
d1.extend("123")
print(d1)
d1 = collections.deque()
d1.extendleft("123")
print(d1)

得到的结果：
deque(['1', '2', '3'])
deque(['3', '2', '1'])

有序字典 (OrderedDict)

创建有序字典
使用lambda表达式lambda s:s[0]和lambda s:s[1]，分别指定key为data中每个元素（tuple类型）的第一个元素和第二个元素

data = [('a',1),('b',3),('c',2)]
od = collections.OrderedDict(sorted(data,key=lambda s:s[0]))#按数据中key值的大小排序
print(od)
od = collections.OrderedDict(sorted(data,key=lambda s:s[1]))#按数据中value值的大小排序
print(od)

得到的结果是：
OrderedDict([('a', 1), ('b', 3), ('c', 2)])
OrderedDict([('a', 1), ('c', 2), ('b', 3)])

这里使用的sorted函数，它返回对一个可迭代对象排序后的结果，如果可迭代对象的元素不能直接进行比较（比如元素是一个list或tuple等），则需要指定key函数。
修改顺序
move_to_end函数

dt = collections.OrderedDict()
dt['a'] = 0
dt['b'] = 1
dt['c'] = 2
dt.move_to_end('b',last = False) #将`b`键值对移动到最前方
print(dt)
dt.move_to_end('b',last = True) #将`b`键值对移动到最后方
print(dt)

得到的结果是：
OrderedDict([('b', 1), ('a', 0), ('c', 2)])
OrderedDict([('a', 0), ('c', 2), ('b', 1)])