随堂笔记

续接列表；

查：list1.index("Runoob")返回查找到的下标

list1=['hongloumeng','xiyouji','taishanguila’]

print(list1.index('xiyouji')) 执行结果为1

 用 in /not in可以查找该对象是否存在列表内

list1=['hongloumeng','xiyouji','taishanguilai',]

print('xiyouji' in list1)  执行结果为True
print('xiyouji' not in list1)     执行结果为False

列表还可以多层嵌套如下：

可根据对应的下标查找对应的对象
list2=[['hongloumeng','xiyouji','taishanguilai'],['曹雪芹','吴承恩'],['李白']]
print(list2[1][0])  执行结果 曹雪芹
print(list2[0][2])    执行结果taishanguilai

list函数

len(list)：获取列表元素的个数实例如下：

list1=['hong','xiji','guilai',3,33,]
print(len(list1)) 结果5
我们还可以用循环遍历一下:
for j in range(len(list1)):
    print(j) 结果0 1 2 3 4

max(list):获取列表内元素最大值举例：

list1=['Google', 'Runoob', 'Taoba']
print(max(list1)) 结果Tabao(字母排序规则以ascii表为准)

当列表内出现不同元素时结果报错举例如下：

list2=[123,456,1234,True,'yuan']
print(max(list2))
TypeError: '>' not supported between instances of 'str' and 'int'

不兼容

min(list):获取列表内元素最小值实例同上类似；

list(元组)：将元组转换为列表举例：

a=list((3,4,"tyu","tt"))
print(a) 输出结果:[3, 4, 'tyu', 'tt']

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

sort()方法语法：

list.sort([func])

func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

该方法没有返回值，但是会对列表的对象进行排序

list1=[1,3,4,0,2,7]
list1.sort()
print(list1) 输7出0 1 2 3 4 7

list.clear():清空列表，没有返回值

list1=[1,3,4,0,2,7]
list1.clear()
print(list1) 输出[  ]

list.copy():复制列表得到返回值

list1=[1,3,4,0,2,7]
list2=list1.copy()
print(list2) 结果  [1,3,4,0,2,7]

元组：( ,)

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

如下实例：

tup1=[1,2,3,456]

tup2=(1,3,"baiyun","黑土")

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

tup1=(2)
print(tup1)  不加逗号输出2
print(type(tup1)) <class'int'>
tup2=(2,)
print(tup2)   加逗号输出(2,)
print(type(tup2))  <class 'tuple'>

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

元组可以使用下标索引来访问元组中的值，如下实例：

tup1=(1,2,3,"yuyuzhongsheng")
print(tup1[3]) 输出yuyuzhongsheng

 

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

tup1=(1,2,3,"yuyuzhongsheng")
del tup1
print(tup1) 执行结果:NameError: name 'tup1' is not defined

元组的运算符：

 ()*int复制元素实例：

tup1=("hello!",)*3
print(tup1)    输出('hello!', 'hello!', 'hello!')

我们可以用“+”对元组进行连接组合，如下实例:

tup1=(1,2,3,"yuyuzhongsheng")
tup2=(1,True,"拜师","aima")
tup3=tup1+tup2

print(tup3)

输出结果(1, 2, 3, 'yuyuzhongsheng', 1, True,'拜师', 'aima')

a in/not ()判断是否在元组内举例：

tup1=(1,2,3,"yuyuzhongsheng")
print(3 in tup1)   True
print(3 notin tup1) False

当然我们还可以用for in来迭代：

for j in (1,2,4,"yu"):
    print(j) 执行结果;1 2 4 yu

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

tup1=("meinv","heitu",123,True,"你好")
print(tup1[1:3]) ('heitu', 123)
print(tup1[-1:0:-1])('你好', True, 123, 'heitu')
print(tup1[3])  True

元组内置函数：

len()计算元组内元素的个数实例如下：

tup1=(1,2,3,"yuyuzhongsheng")
print(len(tup1)) 结果4

max()获取元组内最大值；min()最小值实例：

tup1=(123,1,23,3,5,)
print(max(tup1))  123
print(min(tup1))  1

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

list1=["yuyi",123,"海天"]
tup2=tuple(list1)
print(type(tup2)) 数据判断<class'tuple'>
print(tup2)    结果('yuyi', 123, '海天')

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割,格式如下所示：

d ={key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict1={"name":"梨花带雨","age":23}
dict2={"名字":"梨花带雨","18":23}
print(dict1["name"])  梨花带雨
print(dict2['18'])   23

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例:

dict1={["name"]:"梨花带雨","age":23}
print(dict1["name"])  结果TypeError: unhashable type: 'list'

字典内置函数及方法：

clear()用于删除字典内所有元素；

dict1={"niyt":"yuji",(5,6.7):67}
dict1.clear()
print(dict1) 执行结果{ }

del ()可用于删除单个元素，当删除所有元素时字典不存在

dict1={"niyt":"yuji",(5,6.7):67}
del dict1['niyt'] 执行结果{(5,6.7):67}
del dict1
print(dict1)  执行结果name 'dict1' isnot defined

copy()复制字典得到返回值：

dict1={"niyt":"yuji",(5,6.7):67}
dict2=dict1.copy()
print(dict2)  #执行结果{"niyt":"yuji",(5,6.7):67}

 fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

fromkeys()方法语法：

dict.fromkeys(seq[, value]))

seq --字典键值列表。

value-- 可选参数, 设置键序列（seq）的值。

返回值：该方法返回列表。小例：

seq=("hello","hi","yuni")
dict1=dict.fromkeys(seq)结果{'hello':None, 'hi': None, 'yuni': None}
dict1=dict.fromkeys(seq,12)
print(dict1)  #结果{'hello':12, 'hi': 12, 'yuni': 12}

 get() 函数返回指定键的值，如果值不在字典中返回默认值。

get()方法语法：

dict.get(key,default=None)

key --字典中要查找的键。

default-- 如果指定键的值不存在时，返回该默认值值。

返回指定键的值，如果值不在字典中返回默认值 None。

dict={"name":"xiaoming","age":12}
print("name的值：",dict.get("name"))   执行结果xiaoming
print("sex的值：",dict.get("sex"))  执行结果 None

in 操作符用于判断键是否存在于字典中，如果键在字典dict里返回true，否则返回false。

dict={"name":"xiaoming","age":12}
print("xiaoming"in dict) false(值无法判断)
print("age" in dict)   True

 items() 方法以列表返回可遍历的(键, 值) 元组数组。

items()方法语法：

dict.items()

返回可遍历的(键, 值) 元组数组。

dict={"name":"梨花带雨","age":23}
print( dict.items())
输出结果:dict_items([('name', '梨花带雨'), ('age', 23)])

keys() 方法以列表返回一个字典所有的键。

keys()方法语法：

dict.keys()

返回一个字典所有的键。

 

实例如下：

dict={"name":"梨花带雨","age":23}
print( dict.keys())
输出结果:dict_keys(['name', 'age'])

 values() 方法以列表返回字典中的所有值。

values()方法语法：

dict.values()

返回字典中的所有值。

dict1={"name":"梨花带雨","age":23}
print( dict1.values())
执行结果 dict_values(['梨花带雨', 23])

setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。

setdefault()方法语法：

dict.setdefault(key,default=None)

key --查找的键值。

default-- 键不存在时，设置的默认键值。

如果 key 在字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。

dict1={"name":"梨花带雨","age":23}
print( dict1.setdefault("age","meiyou")) 结果23
print( dict1.setdefault("sex","meiyou")) 结果:不存在报meiyou

 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。

pop()方法语法：

pop(key[,default])

key: 要删除的键值

default:如果没有 key，返回 default 值

返回被删除的值。

dict1={"name":"梨花带雨","age":23}
print( dict1.pop("age","没找到")) 结果23
print( dict1.pop("sex","没找到")) 结果没找到