python入门速通基础
介绍
本文将介绍常用函数，语法，对象类型等等
这一文章是本人做题中遇到的难点和总结，一部分源于网上，一部分自己写的。若有错误，谢谢指出。
一些基础知识来源于链接: 菜鸟
列表（List）
序列是 p y t h o n 中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置或称索引，第一个索引是 0 0 0，第二个索引是 1 1 1，以此类推。
列表是最常见的 p y t h o n 数据类型，它可以作为一个方括号内的逗号分隔值出现
列表可以相当c++中的队列和栈的功能，适用性非常强。
列表的数据项不需要具有相同的类型。
创建一个列表，只要把逗号分割的不同的数据项使用方括号括起来即可。
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
访问列表中的值
使用下标索引来访问列表中的值，同样的你也可以是同方括号的形式截取字符
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# result
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
更新列表
你可以对列表的数据项进行修改或更新，你也可以使用()方法来添加列表项。
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
print list
# result
['Google', 'Runoob']
删除列表元素
可以使用 d e l del del语句来删除列表的元素
list1 = ['physics', 'chemistry', 1997, 2000]print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
# result
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
p y t h o n 列表脚本操作
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
list1 = []
for i in range(5):list1.append(i)
print(list1)
list2 = [5,6,7,8,9]list3 = list1 + list2
list4 = list3 *2
print(list3)
print(list4)
# result
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list1 = [1,2,3]
print(len(list1))
print(3 in list1)for i in list1:print(i,end=' ')
# result
3
True
1 2 3
元组(tuple)
p y t h o n 的元组与列表类似，不同之处在于元组不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号内添加元素，并使用逗号隔开即可。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
tup1 = ()
tup1 = (50,)
元组与字符串类似，下标索引从 0 0 0开始，可以进行截取，组合等
访问元组
元组可以使用下标索引来访问元组中的值。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
# 运行结果
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
# result
(12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的，但我们可以使用 d e l del del语句来删除整个元组。
tup = ('physics', 'chemistry', 1997, 2000)print tup
del tup
print "After deleting tup : "
print tup
# result
NameError: name 'tup' is not defined #tup删除后不存在
元组运算符
与字符串一样，元组之间可以使用 + + +号和 ∗ * ∗号进行运算，这就意味着他们可以组合和赋值，运算后会生成一个新的元组。
a = (1,2,3) + (4,5,6)
b = ('132',)*3
# 这里注意如果写成('123')*3的运行出来的result是132132132
length = len(a)print(a)
print(b)
print(length)
# result
(1, 2, 3, 4, 5, 6)
('132', '132', '132')
6
_in_运算符判断是否在元组中，是的话返回True，否则返回False
_for in_运算符用来遍历元组中所有元素
a = (1,2,3)
s = list(i for i in a)print ( 3 in a)
print(s)
# result
True
[1, 2, 3]
元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中某一段元素
L = ('spam', 'Spam', 'SPAM!')print(L[2])
print(L[-1])
print(L[1:])
#result
SPAM!
SPAM!
('Spam', 'SPAM!')
任何无符号的对象，以逗号隔开，默认为元组
a = 1,2,3,4,5
print(type(a))
# result
<class 'tuple'>
字典是一种可变容器模型，且课存储任意类型对象
字典的每一个键值key:value对（key为键，value为值）用冒号:隔开，每个键值对之间用逗号，号分割，整个字典包括在花括号{}中，格式如下：
d = {key1 : value1, key2 : value2 }
注意：dict作为 p y t h o n 中的关键字和内置函数，变量名不建议命名为 d i c t dict dict(可命名为dict1，dict2等等)
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
zd = {'a': 1 , 'b':2 , 'b':3
}
print(zd['b'])
print(zd)
# 运行结果
3
{'a': 1, 'b': 3}
值可以去任何数据类型，但键必须是不可变得，如字符串，数组，元组。
一个简单例子：
tinydict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可以这样创建：
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
访问键对应的值：
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}print "tinydict['Name']: ", tinydict['Name']
print "tinydict['Age']: ", tinydict['Age']
如果字典中不存在要访问的值就会报出：
修改字典
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']
能删单一的元素也能清空字典，清空只需一项操作。
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}del tinydict['Name'] # 删除键是'Name'的键值对
tinydict.clear() # 清空字典所有条目
del tinydict # 删除字典print(tinydict['Name']) # 由于不存在键值对，会报出KeyError
print "tinydict['Age']: ", tinydict['Age']
print "tinydict['School']: ", tinydict['School']
字典键的特性
字典值可以没有限制地取任何 p y t h o n 对象，既可以是标准地对象，也可以是用户定义的，但键不行
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': 'Manni'} print "tinydict['Name']: ", tinydict['Name']
# 运行结果
tinydict['Name']: Manni
inydict = {['Name']: 'Zara', 'Age': 7} print "tinydict['Name']: ", tinydict['Name']
# 运行结果
TypeError: unhashable type: 'list'
try-语句块 海象运算符 列表推导式 List的常用函数
简单的函数有：
接下的函数最好单独一行，不要出现print（list.()）这样的语句，会打印出None，而不是所期望的值。
list1.(obj)
aList = [123, 'xyz', 'zara', 'abc']
aList.append( 2009 )
print ("Updated List : ", aList)
# result
Updated List : [123, 'xyz', 'zara', 'abc', 2009]
list2.count(obj)
aList = [123, 'xyz', 'zara', 'abc', 123]print ("Count for 123 : ", aList.count(123))
print ("Count for zara : ", aList.count('zara'))
# result
Count for 123 : 2
Count for zara : 1
list3.count(obj)
list1 = [1,2,3,4]
dict1 = {'a':1,'b':2}list1.extend(dict1)
print(list1)
# result
[1, 2, 3, 4, 'a', 'b']aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)print ("Extended List : ", aList)
# result
Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
list4.index(x[, start[, end]])
aList = ['runoob', 'xyz', 'runoob', 'abc']print ("runoob 索引位置: ", aList.index( 'runoob' ))
print ("runoob 索引位置 : ", aList.index( 'runoob', 1, 3 ))
# result
runoob 索引位置: 0
runoob 索引位置 : 2
list5.()
aList = [123, 'xyz', 'zara', 'abc']
blist = [1,2,3,5,6]
aList.insert(3, blist)print("Final List : ", aList)
# result
Final List : [123, 'xyz', 'zara', [1, 2, 3, 5, 6], 'abc']
list6.pop()
list1 = ['Google', 'Runoob', 'Taobao']
list_pop = list1.pop(1)
print("删除的项为 :", list_pop)
print("列表现在为 : ", list1)
# result
删除的项为 : Runoob
列表现在为 : ['Google', 'Taobao']
list7.()
aList = [123, 'xyz', 'zara', 'abc', 'xyz']aList.remove('xyz')
print ("List : ", aList)
aList.remove('abc')
print ("List : ", aList)
# result
List : [123, 'zara', 'abc', 'xyz']
List : [123, 'zara', 'xyz']
list8.()
aList = [123, 'xyz', 'zara', 'abc', 'xyz']aList.reverse()
print ("List : ", aList)
# result
List : ['xyz', 'abc', 'zara', 'xyz', 123]
list9.sort()
def takeSecond(elem):return elem[1]# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]# 指定第二个元素排序
random.sort(key=takeSecond)# 输出类别
print('排序列表：')
print(random)
# result
排序列表：
[(4, 1), (2, 2), (1, 3), (3, 4)]
.(seq)
aList = [123, 'xyz', 'zara', 'abc', 123]
bList = [2009, 'manni']
aList.extend(bList)print ("Extended List : ", aList )
# result
Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
字典常用函数
cmp(dict1,dict2)
len(dict2)
str(dict3)
dict4.clear()
tinydict = {'Name': 'Zara', 'Age': 7};print ("Start Len : %d" % len(tinydict))
tinydict.clear()
print ("End Len : %d" % len(tinydict))
dict5.copy()
dict1 = {'user':'runoob','num':[1,2,3]}dict2 = dict1 # 浅拷贝: 引用对象
dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用# 修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)# 输出结果
print(dict1)
print(dict2)
print(dict3)
# result
{'num': [2, 3], 'user': 'root'}
{'num': [2, 3], 'user': 'root'}
{'num': [2, 3], 'user': 'runoob'}
#实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。
dict6.(seq[, value])
dict7.get(key,[,value])
tinydict = {'Name': 'Runoob', 'Age': 27}print ("Age : %s" % tinydict.get('Age'))# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : %s" % tinydict.get('Sex')) # 没有设置 Salary，输出默认的值 0.0
print ('Salary: %s' % tinydict.get('Salary', 0.0))
# result
Age : 27
Sex : None
Salary: 0.0
dict8.(key)
dict9.items()
dict1 = {'a':1, 'b':2
}
print(dict1.items())
# result
dict_items([('a', 1), ('b', 2)])
.keys()
dict1 = {'a':1, 'b':2
}
print("%s" % dict1.keys())
print("%s" % list(dict1.keys()))
# result
dict_keys(['a', 'b'])
['a', 'b']
.(key,=None)
dict1 = {'a':1, 'b':2
}
print(dict1.setdefault('s',"no"))
print(dict1)
# result
no
{'a': 1, 'b': 2, 's': 'no'}
.()
.()
tinydict = {'Name': 'Runoob', 'Age': 7}print ("Value : %s" % tinydict.values())
print ("Value : %s" % list(tinydict.values()) )
# result
Value : dict_values(['Runoob', 7])
Value : ['Runoob', 7]
.pop(key,[,])
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}element = site.pop('name')print('删除的元素为:')
print(element)
print('字典为:')
print(site)
# result
删除的元素为:
菜鸟教程
字典为:
{'url': 'www.runoob.com', 'alexa': 10000}
.()
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)
print(site)
# result
('url', 'www.runoob.com')
{'name': '菜鸟教程', 'alexa': 10000}
逻辑运算
or运算符
快捷键介绍 函数介绍
split()函数
用法 : str.split(str=“”,num=.count(str))[n]
s t r str str:表示为分隔符，默认为空格，但是不能为空(’’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
n u m num num :表示分割次数。如果存在参数num，则仅分隔成 $num+1 $个子字符串，并且每一个子字符串可以赋给新的变量
[ n ] [n] [n]:表示选取第 n n n个分片
string = “www.gziscas.com.cn”1.以’.'为分隔符print(string.split(’.’))[‘www’, ‘gziscas’, ‘com’, ‘cn’]2.分割两次print(string.split(’.’，2))[‘www’, ‘gziscas’, ‘com.cn’]3.分割两次，并取序列为1的项print(string.split(’.’,2)[1])gziscas
list()函数：
list()函数是的内置函数。它可以将任何可迭代数据转换为列表类型，并返回转换后的列表。当参数为空时，list函数可以创建一个空列表。
print()函数
a = 1
b = 2
sum = a + b
print( f"{a} + {b} = {sum}")
print("{0} + {1} = {2} ".format(a,b,sum))
print("%d + %d = %d"%(a,b,sum))
int(x,base=10)
x x x代表的是字符串或数字，base代表的进制数，默认十进制。将字符串（base进制下的）转化成数字（十进制下的）
输入的字符串如果是‘123’，就是代表123，输入的必须是数字。否则会报错
strip()，(),()
依次是
使用方法
str1.strip()
str2.lstrip()
str3.rstrip()
()
可以去除可以去除全部空格，主要用于字符串的替换(old, new, count)
old是需要替换的值，new是替换后的值，max是最多替换的次数
str = "我把你当亲兄弟对待，而你却像对待爸爸一样对待我？这是为什么？？？？？";
print( str.replace("爸爸", "爷爷"))
print(str.replace("？", "：", 3))
#result
我把你当亲兄弟对待，而你却像对待爷爷一样对待我？这是为什么？？？？？
我把你当亲兄弟对待，而你却像对待爸爸一样对待我：这是为什么：：？？？
join()
用法：
‘sep’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
str = "I am your father"
print(':'.join(str))
# result
I: :a:m: :y:o:u:r: :f:a:t:h:e:r
map()
用法：
map() 会根据提供的函数对指定序列做映射。
第一个参数 以参数序列中的每一个元素调用 函数，返回包含每次 函数返回值的新列表。
>>> def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
<map object at 0x100d3d550> # 返回迭代器
>>> list(map(square, [1,2,3,4,5])) # 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
用法介绍
print（a）和print（*a）的区别
a = [1,2,3,4,4,5]
print(*a, sep=' ')
print(a,sep=' ')
# 运行结果
1 2 3 4 4 5
[1, 2, 3, 4, 4, 5]
dict[keys,]和dict(zip(keys,))的区别
keys= ['a','b']
values = [1,2]
print(dict([keys,values]))
print(dict(zip(keys,values)))
# 运行结果
{'a': 'b', 1: 2}
{'a': 1, 'b': 2}如果在前面加一个*
如：print(*dict(zip(keys,values)))会怎么样?
# 运行结果
a b
格式化输出
的格式化输出主要有四种方式：
name = input()
print(f'I am {name} and I am studying Python in Nowcoder!')name = input()
print('I am {} and I am studying Python in Nowcoder!'.format(name))
name = input()
print('I am %s and I am studying Python in Nowcoder!'%name)
print("I am",input(),"and I am studying Python in Nowcoder!")
注意
name = input()只能读入一个数据，数字，字符串等，不能是多个。
而输入name =input("").split(" ")(注意split（“”）中的“”中间无内容会报错，空格算内容)，这样的输入可以输入一个多个数字，字符串，都会放在列表中。但是如果是:
name1,name2 = input("请输入").split(" ")
此时就不能随意输入多个数据，必须是和前面变量对应数量的个数，否则也会报错。
注意事项
input().split("\n")无法实现隔行读取
在中，字符串是不可变的，也就是你不能直接修改字符串中的某个字符。当你尝试执行 str1[0] = str((int(str1[0]) + 3) % 9) 这行代码时，会抛出一个错误，提示你不能为字符串的指定位置赋值。
如果你想修改字符串中的某个字符，可以考虑将字符串转换为列表，进行修改后再转换回字符串。例如：
str1 = list(str1)
str1[0] = str((int(str1[0]) + 3) % 9)
str1 = ''.join(str1)
这样就可以实现将字符串中的第一个字符修改为 (int(str1[0]) + 3) % 9 的结果。
为什么下面这段代码不能执行对list1的修改？
str1 = input()
list1 = list(str1)
for i in range(len(list1)):list1[i] = str((int(list1[i]) + 3) % 9)print(list1)
答：
这段代码没有改变列表 list1 中的元素，是因为在循环中你使用的是变量 i ，它仅仅是一个迭代器，赋值操作并不会修改列表元素本身。每次迭代，i 都指向列表中的一个元素，但是对 i 的修改并不会反映到列表中。
如果你想要修改列表中的元素，可以通过索引直接访问和修改元素。以下是修正后的代码：
str1 = input()
list1 = list(str1)
for i in range(len(list1)):list1[i] = str((int(list1[i]) + 3) % 9)print(list1)
index和find函数的区别：
下标索引不会越界，但是下标使用会越界(列表，元组，字符串，字典)
list1 =[ 1,3,4,5,5]
print(list1[1:100000])
# result
[3, 4, 5, 5]
list1 =[ 1,3,4,5,5]
print(list1[8])
# result
list index out of range
对于字典一样，如果查找的键不在字典中，就会报错
所以防止报错，一般在字典中查找一个不确定在不在字典中的键时，我们使用in先检测是否在字典中
name in dict1 and secret == dict1[name]
保留小数
主要有三种方法
float转int
float转成int只需要int（）函数即可。
但是在输入字符串数，可能有人会想能不能直接通过int（）转换，如将字符”12.3“直接转成12:
value1 = int(input())
答案是不行的，字符串"123.123"不能通过int（）直接转换成123
正确做法是：
value1 = int(float(input()))
16进制转10进制
16进制转10进制，使用int()函数即可。
print(int(input(),base=16))
字母大小写转换
主要有两种方法：
逐个遍历
没有所谓的字符这个概念，所以更不可能存在c++中的A =‘\32’。如果要将要取出字符，要不然用下标索引，要不然直接用for in语句。
msg = 'Niu Ke le'
for num in msg:if 97 <= ord(num) <= 122: #小写字母upper_num = ord(num)-32 #大小写字母之前差了32#chr()函数可以将编码数值转为字符（python没有字符的概念）print (chr(upper_num),end='')else:print(num,end='') #不是小写字符，原样输出
print() #输出一个换行符
msg = 'Niu Ke le'
for num in msg:if 65 <= ord(num) <= 90: #大写字母upper_num = ord(num)+32 #大小写字母之前差了32#chr()函数可以将编码数值转为字符（python没有字符的概念）print (chr(upper_num),end='')else:print(num,end='') #不是大写字符，原样输出
# result
NIU KE LE
niu ke le
直接使用现有函数
.lower() --- 全部小写
.upper() --- 全部大写
.title() --- 各个字符的首字母大写
.capitalize() --- 首字母大写
*和**的用法
print("hi"*3)
# result
hihihi
def func(*p):print(p)func (1,2,3,4,4)
# result
(1, 2, 3, 4, 4)
** 下标索引的用法
s t r n a m e [ s t a r t : e n d : s t e p ] [start : end : step] [start:end:step]
对各个部分的说明：
值得一提的是，下标索引不会越界：
a = '123'
b = a[:5]
print(b)
# result
123
如何实现多行输入 如何解决index找不到元素时报错
list1 = input().strip().split()
name = input()if ( name in list1):print(list1.index(name))
else:print(False)
如何快速打印列表中的所有元素 如何判断列表是否为空
if ( list1 ):
if (len(list1) == 0)
if-else的特殊用法 对于二维列表的列表解析
如果存在一个矩阵 x x x，让你求解 3 x 3x 3x的值，你要怎么做?
矩阵如图所示，输入一个n，求解 n x nx nx，打印出该列表。
1 2 3 4 5 6 7 8 9 \begin{} 1&2&3\\ 4&5&6\\ 7&8&9\\ \end{} 147258369
中输入转列表/元组 元组能不能使用列表解析
list1 =[i for i in range(0,6) if i %2 == 0]
print(list1)
# result
[0, 2, 4]
zip()和()
在中，zip()和()是两个不同的内置函数，它们具有不同的功能和用途。
zip()函数用于将多个可迭代对象（如列表、元组等）中对应位置的元素打包成一个新的元组，返回一个迭代器。每个元组的元素来自于不同的可迭代对象在相同位置的元素。
例如：
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
result = zip(list1, list2)
print(list(result)) # [(1, 'a'), (2, 'b'), (3, 'c')]
zip()函数可以用于快速组合多个列表或元组的元素，通常与循环结构一起使用。
()函数用于创建一个新的字典，其中指定的键被设置为同一个值（默认为None），返回这个新的字典。
例如：
keys = ['a', 'b', 'c']
value = 0
result = dict.fromkeys(keys, value)
print(result) # {'a': 0, 'b': 0, 'c': 0}
()函数可以用于快速创建包含特定键和默认值的字典。
总结：
它们的区别主要在于功能和用途。zip()用于组合多个可迭代对象的元素，而()则用于创建新的字典。
什么时候可以使用list()转换成列表
在中，可以使用list()函数将可迭代对象转换为列表。可迭代对象是指可以被迭代遍历的对象，比如字符串、元组、集合、字典等。
list()函数可以接受不同类型的可迭代对象作为参数，并将其转换为列表。具体转换规则如下：
如果可迭代对象是一个字符串，list()函数会将字符串中的每个字符作为列表的一个元素。
my_str = "Hello"
my_list = list(my_str)
print(my_list)
输出结果：
['H', 'e', 'l', 'l', 'o']
如果可迭代对象是一个元组，list()函数会将元组的元素作为列表的元素。
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)
输出结果：
[1, 2, 3]
如果可迭代对象是一个集合，list()函数会将集合的元素作为列表的元素。由于集合无序且元素不可重复，生成的列表也无序且元素不重复。
my_set = {1, 2, 3}
my_list = list(my_set)
print(my_list)
输出结果：
[1, 2, 3]
如果可迭代对象是一个字典，list()函数会将字典的键作为列表的元素。注意，字典的元素顺序是不确定的，因为字典是无序的数据结构。
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
my_list = list(my_dict)
print(my_list)
输出结果：
['name', 'age', 'city']
需要注意的是，list()函数并不递归地将可迭代对象中的所有元素都转换为列表。它只转换最外层的元素。如果你希望将嵌套的可迭代对象转换为列表，可以使用递归或其他方法来实现。
总结来说，当你需要将可迭代对象转换为列表时，可以使用list()函数来实现。这对于需要使用列表数据结构的场景非常有用。
什么时候可以使用dict()转换成字典
在中，可以使用dict()函数将可迭代对象转换为字典。可迭代对象是指可以被迭代遍历的对象，比如列表、元组、集合等。
dict()函数可以接受不同类型的可迭代对象作为参数，并根据不同的情况将其转换为字典。具体转换规则如下：
如果可迭代对象是一个包含可哈希的键值对元组的列表，那么dict()函数会将其转换为字典。每个键值对元组中，第一个元素会被视为键，第二个元素会被视为对应的值。
my_list = [('name', 'John'), ('age', 30), ('city', 'New York')]
my_dict = dict(my_list)
print(my_dict)
输出结果：
{'name': 'John', 'age': 30, 'city': 'New York'}
如果可迭代对象是一个包含可哈希的键值对元组的元组（或其他可迭代对象），那么dict()函数也会将其转换为字典。每个键值对元组中，第一个元素会被视为键，第二个元素会被视为对应的值。
my_tuple = (('name', 'John'), ('age', 30), ('city', 'New York'))
my_dict = dict(my_tuple)
print(my_dict)
输出结果同样为：
{'name': 'John', 'age': 30, 'city': 'New York'}
如果可迭代对象是一个包含可哈希的键值对元组的集合，处理方式与列表类似。
my_set = {('name', 'John'), ('age', 30), ('city', 'New York')}
my_dict = dict(my_set)
print(my_dict)
输出结果同样为：
{'name': 'John', 'age': 30, 'city': 'New York'}
需要注意的是，在转换过程中，dict()函数会自动忽略重复的键值对。只有最后一个具有相同键的键值对将保留在生成的字典中。
当你需要将可迭代对象转换为字典时，可以使用dict()函数来实现这个转换。这在处理需要使用字典数据结构的数据时非常有用。
需要熟悉的代码
dict1 = {'<': 'less than','==': 'equal'}
print('Here is the original dict:')
for x in sorted(dict1):print(f"Operator {x} means {dict1[x]}.")
print("")
dict1['>'] = 'greater than'
print("The dict was changed to:")
for x in sorted(dict1):
print(f'Operator {x} means {dict1[x]}.')
dict1 = {'name': 'Niuniu','Student ID': 1}
dict2 = {'name': 'Niumei','Student ID': 2}
dict3 = {'name': 'Niu Ke Le','Student ID': 3}
list1 = []
list1.append(dict1)
list1.append(dict2)
list1.append(dict3)for i in list1:print(f"{i['name']}'s student id is {i['Student ID']}.")
dict1 ={'Beijing': {'Capital': 'China'},'Moscow': {'Capital': 'Russia'},'Paris': {'Capital': 'France'}}for i in sorted(dict1):print(f"{i} is the capital of {dict1[i]['Capital']}!")
