Python基础学习——字符串、列表、元组、字典、集合

一、字符串操作

　　注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

  一）用途：名字，性格，地址

name = 'wzs' #name = str('wzs')
print(id(name),type(name),name)

  二）优先掌握的

# 优先掌握的
切片 顾头不顾尾
msg='hello world'
##正向取值
print(msg[1:3])
print(msg[1:10:2])  #哪 到哪 步长
print(msg[:])
print(msg[::2])
#反向取值
print(msg[::-1])  #步长可以为负值
print([])
长度len
msg1 = 'qna ss'
print(len(msg1))

成员运算 in和not in
msg = 'hello world'
print('he' in msg)
print('ho' not in msg)

移除空白（默认去掉字符串两端的空格）strip
password = 'alex3714  '
##可以不做赋值操作
print(password.strip())
##去掉指定的字符
msg2 = '*******eg**on*****'
print(msg2.strip('*'))
msg3 = '  ****wzs  *****   '
print(msg3.strip(' |*'))

#切分split 指定分隔符(默认以空格为分隔符)
取出用户名
user_info = 'root:x:0:0:root:/root:/bin/bash'
# print(user_info[0:4])
print(user_info.split(':')[0]) #两个参数，以什么为分割和最多切割几次，默认有多少分割符，就切多少次
print(user_info.split(':',1)[0])  #以什么分割，分割多少次

  三）常规操作

# isdigit 用来判断字符中是否是由纯数字组成(bytes 或Unicode组成)

msg = '******alex****'
print(msg.strip('*'))
print(msg.lstrip('*'))
print(msg.rstrip('*'))

msg = 'my name is wzs,my age is 18'
print(msg.startswith('my'))  #以什么开头
print(msg.endswith('18'))   #以什么结尾

print(msg.replace('my','wzs',1))

#格式化输出
# 方式一
print('my name is %s,my age is %s' %('wzs',27))
# 方式二
print('my name is {},my age is {}'.format('wzs',27) )
# 方式三：打印指定位置的元素
print('{1} {0} {1}'.format('egon',18))
print('my name is {x},my age is {y}'.format(y=27,x='wzs'))

join连接
user_info = 'root:x:0:0:root:/root:/bin/bash'
l = user_info.split(':')
print(l) #以什么为分隔，以列表显示
print(':'.join(l)) #列表元素用什么连接
print(' '.join(l))

# center,ljust,rjust,zfill
print('wzs'.center(15,'='))  #center把前面的放在中间；总字符数量，其他的用‘=’填充
print('wzs'.ljust(15,'='))  #ljust 把前面的放在左边；总字符数量，其他的用‘=’填充
print('wzs'.rjust(15,'='))   #rjust 把前面的放在右边；总字符数量，其他的用‘=’填充
print('wzs'.zfill(15))  #zfill 把前面的放在右边；总字符数量，其他的用‘0’填充

  四）了解

find,rfind,index,rindex,count
# # find 查找
# msg = 'hello world'
# print(msg.find('ell'))  ##从左到右找，若有，则返回第一个字符的索引
# print(msg.find('ell33'))  ##从左到右找，若没有，则返回-1
# #index 索引
# print(msg.index('e',0,4)) #从左到右找（可以指定范围），若有，则返回返回第一个字符的索引
# # print(msg.index('ell33'))  ##从左到右找（可指定范围），若没有，则会报错  所以不要以index找元素
# # count 统计在某个范围（默认是整个范围）一个fa某个元素的数量
# print(msg.count('l',0,8))
#
# 设定tab空格的数量
# msg='abc\tdeft'
# print(msg.expandtabs(3))
#
# 字母数字判断
# 字母大小写转换
# msg='i am Chinese people'
# # msg = 'wzs112'
# print(msg.capitalize()) #首字母大写
# print(msg.upper()) #字母全转换成大写
# print(msg.lower())  #字母全转换成小写
# print(msg.title())  #单词首字母大写
# print(msg.swapcase())  #变量是否包含空格
#
# is系列
# msg='i am Chinese people'
# print(msg.isupper()) #是否全部大写
# print(msg.islower()) #是否全部小写
# print(msg.istitle()) #是否首字母大写
#
# 字母和数字
# msg='asasdf123'
# print(msg.isalnum()) #字符串是否由字母或数字组成
# msg = 'asdfasdf'
# print(msg.isalpha())  #字符串是否只有字母组成
#
# msg='   '
# print(msg.isspace())  ##是否只有空格
# msg='aaaai fabc'
# print(msg.isidentifier()) #标志符
#
# 判断数字
# age = 27
# inp = input('age>>: ').strip() #输入内容有空格，去掉
# if inp.isdigit():
#     inp=int(inp)
#     if inp > age:
#         print('ok')
# else:
#     print('必须输入数字')
#
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='壹'
num5='Ⅳ' #罗马数字

# bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
print(num5.isdigit())

# unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())
# print(num5.isdecimal())

# unicode,汉字，罗马
# print(num2.isnumeric())
# print(num3.isnumeric())

二、列表操作

　　列表是最常用的数据类型之一，通过列表可以对数据实现方便的存储、修改的等操作

　　列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

　　列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。

　　定义列表：fruits = [“’apple”,”orange“,”pear”,”banana”]

　　列表通过下标，访问数据，下标从0开始，-1 为从末尾的开始位置

变量[头下标:尾下标]

　　注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

  一）常规操作

students = ['wzs','alex','egon',11,['cyy','bjq']]

　　1、切片

 1 print(students[1:5])  

　　2、追加

  1 students.append('oldboy') 

　　3、插入

  1 students.insert(1,'alex') 

　　4、修改

students[2] = 'xiaoming'
print(students)

　　5、删除

1 del students[4] ##del是一种通用的删除方式
2 students.remove('egon')   ##remove按照值去删的，是单纯的删除，不会返回删除的值
3 print(students) 
4 students.pop()  #pop按照索引去删，默认从末尾（-1）开始删除
5 res = students.pop(1)
6 print(res)

　　6、取值

 1 print(students[2]) 

　　7、迭代 extend()方法

　　学习链接地址：https://www.cnblogs.com/wushuaishuai/p/7729011.html

  二）常规操作

1 students = ['wzs','alex','egon',11,['cyy','bjq']]
2 # 插入 指定位置插入值
3 students.insert(1,'alex')
4 #可以以列表的方式追加多个元素到原来列表的末尾
5 students.extend([1,34,5,6])
6 #统计列表某个元素的个数
7 print(students.count('alex'))
8 print(students)

  三）了解

students = ['wzs','alex','egon',11,['cyy','bjq']] 
# 清除列表
print(students.clear())

# 复制
l = students.copy()
print(l)

# 修改原列表，返回Node
# 反转 reverse()  #单纯的反转，将列表的索引顺序从倒过来
students.reverse()
print(students)
print(students.reverse())

# 不改变原列表，返回反转后的新列表（使用列表的切片实现）
l1=l[::-1]
print(l1)

#sort排序，默认是从小到的顺序 
l=[2,44,-2,11,18]
# l.sort()
l.sort(reverse=True)  #从大到小的顺序排序元素
print(l)

python3使用l.sort()返回None。
需要使用sorted(l)进行正序排列，使用sorted(lis,reverse=True) 反序排列

  四）列表合并

• 加号 + 是列表连接运算符：连接列表
• 星号 * 是重复操作：列表乘法运算

　　1、使用“+”号

　　运算符的重载

l1=[1,2,3]
l2=[1212,"hello"]
l3=l1+l2
print(l3)

　　2、使用extend方法

　　方法比较简洁，但会覆盖原始list

l1.extend(l2)
print(l1)

　　3、使用切片进行合并

　　功能比较强大，可以将一个列表插入另一个列表的任意位置

　　　　以列表的长度切片合并，结果和前两种方法结果一样。在前面列表尾部插入列表。

l1[len(l1):len(l1)]=l2
print(l1)

　　　　在前面的开头插入列表

l1[0:0]=l2
print(l1)

　　　　也可以指定任意位置插入

l1[1:1]=l2
print(l1)

  五）练习

队列和堆栈（append和pop实现）

#队列 先进先出
# 使用apend
# l1=[]
# l1.append('first')
# l1.append('second')
# l1.append('third')
# print(l1)
# print(l1.pop(0))
# print(l1.pop(0))
# print(l1.pop(0))

#堆栈 先进后出
# print(l1.pop(-1))
# print(l1.pop(-1))
# print(l1.pop(-1))

队列和堆栈（append和pop实现）

队列和堆栈（insert和pop实现）

#使用insert和pop
l2=[]
l2.insert(0,'four')
l2.insert(0,'five')
l2.insert(0,'six')
print(l2)
##堆栈 后进先出原则
# print(l2.pop(0))
# print(l2.pop(0))
# print(l2.pop(0))
##队列 先进先出原则
print(l2.pop(-1))
print(l2.pop(-1))
print(l2.pop(-1))

队列和堆栈（insert和pop实现）

三、元组

　　作用：存多个值，对标列表来说，元组不可变（是可当作字典的key的），主要用来读

• 元组比列表更节省空间。
• 元组其实跟列表差不多，只是元组一旦创建，便不能再修改，所以又叫只读列表
• 元组写在小括号 () 里，元素之间用逗号隔开

　　定义元组：names = (“wzs”,"alex","egon")

　　只有两个方法，一个count，一个index

1 salary = (12000,18000,9000,36000)
2 # print(id(salary),type(salary),salary)

　　注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

  一）优先掌握的操作

1 # 按索引取值(正向取+反向取)
2 print(salary[1])
3 # 切片
4 print(salary[:5:2])
5 #长度(元素的数量)
6 print(len(salary))
7 #成员运算 in和not in
8 print(12000 in salary)

  二）常规操作

1 # index 取索引所对应的值 索引存在，返回相对应的值；不存在报错
2 print(salary.index(12000))
3 # print(salary.index(120001))
4 #count  统计列表中元素的数量
5 print(salary.count(9000))

  三）数据取值操作 for和while循环

 1 #列表、字符串和元组通过索引取值，while循环;
 2 l1 = [12,45,11,66,112]
 3 index = 0
 4 while index < len(l1):
 5     # print(index)  #取索引
 6     print(index,l1[index]) #取索引和索引所对应的值
 7     index +=1
 8 
 9 # #使用for 循环
10 l = ['a','b','t','s','e']
11 #直接取值
12 for item in l:
13     print(item)
14 # 取索引
15 for item in range(len(l)):
16     print(item)

  四）练习

简单购物车,要求如下：
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　

msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
} 

 1 msg_dic={
 2 'apple':10,
 3 'tesla':100000,
 4 'mac':3000,
 5 'lenovo':30000,
 6 'chicken':10,
 7 }
 8 goods_l=[] ##定义购物车
 9 while True:
10     for key in msg_dic: #循环商品列表
11         print(key,msg_dic[key])
12     choice = input("你想购买什么：").strip() ##输入你自己需要的东西，去掉空字符串
13     if choice not in msg_dic:continue #在若你输入的东西不在字典中，停止这个循环，继续输入
14     count = input("个数>>:").strip()
15     if count.isdigit():#判断输入的必须是数字
16         goods_l.append((choice,msg_dic[choice],int(count)))   ##将用户输入信息追加到元组中
17         print(goods_l)

四、字典

　　作用：存多个值，key-value存取，取值速度快

　　定义：key必须是不可变类型，value可以是任意类型

　　语法：

1 info = {
2     'stu001':"小明",
3     'stu002':"小红",
4     'stu003':"小亮",
5 }

　　注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

  一）字典的特性：

　　　　1、字典是无序的

　　　　2、key必须是唯一的

  二）优先的操作：

1  info = {'name':'wzs','age':27,'sex':'male'}

　　1、增加

1 info['hobbies'] = ['running','reading','music']
2 print(info)

　　2、修改

  info['name']='alex'

　　3、删除

1 print(info.pop('name'))  #删除指定的key
2 print(info.pop('wzs',None)) #删除的key不存在，可自定义返回的内容（默认值是None）
3 print(info.popitem()) #随机删除键值对
4 print(info)

　　4、查找

1 info2 = {'name':'wzs','age':20,'sex':'male'}
2 #取值get
3 # print(info2['name12']) ##直接使用key取值，key不在会报错
4 print(info2.get('name12','inexistent')) #使用get取值，存在会返回相应的值；不存在则返回自定义的值
5 print(info2.popitem())  #随机删除一个键值对

　　5、多级字典嵌套机操作

 1 av_catalog = {
 2     "欧美":{
 3         "www.y.com": ["很多免费的,世界最大的","质量一般"],
 4         "www.pornhub.com": ["很多免费的,也很大","质量比y高点"],
 5         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
 6         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
 7     },
 8     "日韩":{
 9         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
10     },
11     "大陆":{
12         "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
13     }
14 }
15 
16 av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
17 print(av_catalog["大陆"]["1024"])
18 #ouput 
19 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

　　6、键值对的数量 len和成员运算

1 print(len(info))
2 # # 成员运算 in 和not in
3 print('name' in info) 

　　7、循环字典

1 for key in info.keys():
2     print(key)
3 for val in info.values():
4     print(val)
5 for item in info.items():
6     print(item) 

  三）常用的方法

setdefault的功能
1：key存在，则不赋值，key不存在则设置默认值
2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值

1 #设定两个参数，分别传值
2 for k,v in info2.items():
3     print(k,v)
4 #设定空键值对
5 print(info2.setdefault('hobbbies',['reading','runnning']))  ##有则不改，返回已有的值；没有则新增，返回新增的值
6 print(info2)
7 #设定空置的键值对
8 print(info2.setdefault('hobbies',[]))
9 print(info2['hobbies'])

判断key是否在字典中，若不在，先创建空值键值对（值为列表），然后追加值到列表；若在的话，追加新值到列表中

 1 info3 = {'name':'wzs','age':20,'sex':'male'}
 2 #方式一
 3 if 'hobbies' not in info3:
 4     info3['hobbies'] = []
 5     info3['hobbies'].append('music')
 6 else:
 7     info3['hobbies'].append('read')
 8 #方式二
 9 info3.setdefault('hobbies',[]).append('music')
10 info3.setdefault('hobbies',[]).append('read')
11 print(info3)

  四）了解的操作

 1 ##update 新增字典的键值对：创建新的字典，使用update将新的字典里面的内容增加到原来的字典中
 2 info = {'name':'wzs','age':27,'sex':'male'}
 3 info_new = {'a':1,'b':16737}
 4 info.update(info_new)
 5 print(info)
 6 
 7 #创建初始化字典
 8 #新字典如下dic={'name':None,'age':None,'sex':None,'hobbies':None}
 9 dic_new = {}.fromkeys(['name','age','sex','hobbies'],None)
10 print(dic_new)

  五）扩展

　　1、有序字典类OrderedDict

　　https://www.cnblogs.com/zhenwei66/p/6596248.html

from collections import OrderedDict

　　2、Python中字典合并的四种方法

　　字典是Python语言中唯一的映射类型。字典是Python中最强大的数据类型之一。
　　映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。
　　字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

　　　　1、字典类型与序列类型的区别：

1. 存取和访问数据的方式不同。
2. 序列类型只用数字类型的键（从序列的开始按数值顺序索引）；
3. 映射类型可以用其他对象类型作键（如：数字、字符串、元祖，一般用字符串作键），和序列类型的键不同，映射类型的键直4.接或间接地和存储数据值相关联。
4. 映射类型中的数据是无序排列的。这和序列类型是不一样的，序列类型是以数值序排列的。
5. 映射类型用键直接“映射”到值。

 　　　　2、具体的方法如下链接

　　Python中字典合并的四种方法_python字典合并值-CSDN博客

　　3、其他

 1 # 1、链式赋值
 2 x=10
 3 y=x
 4 x=y=z=20
 5 print(id(x),id(y),id(z))
 6 #交换两个变量的值
 7 m = 10
 8 n = 20
 9 print(m,n)
10 m,n = n,m
11 print(m,n)
12 
13 # 从一个数据类型中解压出我们想要的值
14 t=(22,433,42,454,99)
15 a,b,c,d,e=t
16 # print(t)
17 # 支取自己想要的值
18 # a,_,_,_,e=t 
19 # print(a,e)
20 a,*_,e=t #等价于上面的
21 print(a,e)
22 
23 # 字典  只取出字典中的key
24 x,y,z={'a':1,'b':2,'c':3}
25 print(x,y,z)

  六）练习

1、有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中

即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}

#1、设定一个空值列表的键值对字典，两个key；使用if判断，符合条件分别放到一个列表中
dic_num = {'k1':[],'k2':[]}
num = [11,22,33,44,55,66,77,88,99,90]
for i in num:
    if i > 66:
        dic_num['k1'].append(i)
    else:
        dic_num['k2'].append(i)
print(dic_num)

2 统计s='hello alex alex say hello sb sb'中每个单词的个数

结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}

方法1 使用for循环

for word in words:
    if word in dic:
        dic[word] +=1
    else:
        dic[word] =1
print(dic)

方法2：统计列表中单词数量即可

#!/usr/bin/env python
# -*- coding:utf-8 -*-

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
for word in words:
    dic[word]=s.count(word)
print(dic)

方法3：使用setdefault

#!/usr/bin/env python
# -*- coding:utf-8 -*-

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
#使用setdefault设定字典的键值对
for word in words:
    dic.setdefault(word,s.count(word))
print(dic)

方法4：使用集合去重，减少循环

#!/usr/bin/env python
# -*- coding:utf-8 -*-

s = 'hello alex alex say hello sb sb'
dic = {}
words = s.split() ##将字符串空格为分隔，转换成列表形式
# print(words)
#使用集合去重，减少循环次数
words_set = set(words)
for word in words_set:
    dic[word]=s.count(word)
print(dic)

五、集合操作

　　集合是一个无序的，不重复的数据组合，他的主要作用是

1. 去重，把一个列表整合，就自动去重了
2. 关系测试，测试两组数据之前的交集、差集、并集等等

定义集合：
    集合：可以包含多个元素，用逗号隔开
    集合的元素遵循的三个原则：
        1、每个元素是不可变类型（可hash，可作为字典的key）
        2、没有重复的元素
        3、无序

  一）优先掌握的操作 

　　1、并集：|   交集：&  差集：-  对称差集：^

 1 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
 2 linuxs={'wupeiqi','oldboy','gangdan'}
 3 #| 并集
 4 # print(pythons | linuxs) #并集
 5 # print(pythons.union(linuxs))
 6 #& 交集
 7 # print(pythons & linuxs) #交集
 8 # print(pythons.intersection(linuxs))
 9 #- 差集
10 # print(pythons - linuxs)#差集
11 # print(pythons.difference(linuxs))
12 # print(linuxs - pythons)
13 #^ 对称差集
14 # print(pythons ^ linuxs) #对称差集
15 # print(pythons.symmetric_difference(linuxs))

　　2、> ， >= ， <, <= 父集，子集

 1 # s1={1,2,3,4}
 2 # s2={3,4,5}
 3 # print(len(s1) > len(s2))
 4 #
 5 s1={1,2,3,4}
 6 s2={3,4}
 7 # print(s1 > s2)
 8 print(s1.issubset(s2)) #子集
 9 print(s1.issuperset(s2)) #父集
10 # print(s1 >= s2)

　　3、去重

有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

#列表去重。先转换为集合，去重结束，再转换成列表

方法一：下面的顺序是乱的

1 l=['a','b',1,'a','a']
2 l_new=list()
3 s=set()
4 for item in l:
5     if item not in s:
6         s.add(item)
7         l_new.append(item)
8 print(s)

方法二：下面的方法是保持原来的顺序

1 l=['a','b',1,'a','a']
2 l_new=list()
3 s=set()
4 res=tuple(l)
5 for item in res:
6     if item not in s:
7         s.add(item)
8         l_new.append(item)
9 print(l_new)

有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]　　

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
l_new = list()
s = set()
for item in l:
    res = (item['name'],item['age'],item['sex'])
    if res not in s:
        s.add(res)
        l_new.append(item)
print(l_new)

六、数据类型总结

  一）数据类型分类

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

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

　　2、按存值个数区分

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

　　3、按可变不可变区分

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

　　4、按访问顺序区分

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

  

  二）数据类型转换

　　有时，需要对数据内置的类型进行转换；数据类型的转换，需要将数据类型作为函数名即可。

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

七、字符编码与转码　　

　　字符编码与转码：python基础之字符编码 - linhaifeng - 博客园