21李刚python第二章

创建列表用方括号

列表所包含的元素是可以改变的

my_list = [2,3,‘python’,3.4]
print(my_list)

创建元组用圆括号

元组一旦创建，它所包含的元素是不能改变的

如果创建的元组只有一个元素 ,一定要在元素的后面添加逗号

my_tuple = (3.4，100，‘python’)
print(my_tuple)
#用list函数创建列表
my_list = lidy(range(2,10))
print(my_list)
#用tuple函数创建元组
my_tuple = tuple(range(4,8))
print(my_tuple)

将元组转成list

list2 =list(my_tuple)
print(list2)

将list转成元组

tuple2 = tuple(my_list)
print(tuple2)

my_tuple = tuple (range(3,10))
print(my_tuple)
#len函数可以用于访问列表的长度
print(len(my_tuple))
print(my_tuple[2])#第三个元素
print(my_tuple[-2])#第三个元素
my_list = [‘python’,‘swift’,‘kotlin’,‘java’,‘oc’,‘go’]
print(my_tuple[3]）
print(my_tuple[-3])
#当你索引访问元素时，你的索引必须在-len~len-1之间，否则程序就会报错：index out of range
print(my_tuple[6])
print(my_tuple[-6])
my_tuple = (‘java’,‘js’,20,100,‘kotlin’,‘python’,‘oc’)
#获取子序列（中间一段）
print(my_tuple[2:5])
print(my_tuple[-5:-2])
print(my_tuple[3:-1])
#指定step
print(my_tuple[2: -1 :2])
list1 = [20,‘python’]
list2 = list(range(4))

加法就是把两个列表的元素拼接在一起

print(list1 + list2)
tuple1 = (20,‘python’)
tuple2 = tuple(range(4))
print(tuple1 + tuple2)

如果确实需要将列表和元组相加则可以进行转换

print(list1 + list(tuple2))#print(tuple(list1) + tuple2)
list1 = [‘python’,29,-2]
#序列(字符串,列表也行)只能跟整数相乘，就是把元素重复n次
print(list1 * 3)

mylist = [‘python’,‘kotlin’,‘swift’,‘java’,‘go’,‘sprint’,‘swx’]
#len可以获取序列包含多少元素
print(len(mylist))
#字符串比较大小，先比较第一个字符，如果第一个字符相等，在比较第二个字符。。。
print(max(mylist))
print(min(mylist))
#python会先将多个值封装成元组，然后将元组存入变量
mydata = 25,30,‘python’
print(mydata)
print(type(mydata))

自动解包，列表中的3个值自动赋值给3个变量

mylist = [20,‘fkjava’,3.4]
a,b,c = mylist
print(a)
print(b)
print©

所有序列包括range都支持自动解包

a,b,c,d = range(30,34)
print(a)
print(b)
print©
print(d)
mytuple = (‘python’,‘kotlin’,‘swift’,‘java’,‘go’,‘spring’,‘swx’)
#如果你只要解包某一个值，剩下的值可用一个带*的变量（列表）来接收
first，*rest ,last= mytuple
print(first)#‘python’
print(rest)#‘kotlin’,‘swift’,‘java’,‘go’,‘spring’,‘swx’
print(last)#‘sws’

字符串也是序列，因此也支持解包

a,b,c = ‘fkjava.org’
print(a)#f
print(b)#k
print©#java.org

my_list = [‘python’,‘swift’]
my_list.append(‘kotlin’)
print(my_list)
#为列表append元组，元组将被当成整体
my_list.append(tuple(range(3,6))
print(my_list)
#extend方法用于将序列中的元素添加进来
my_list.extend(range(20,25))
print(my_list)
my_list.extend(“fkjava”)#字符串也是序列
print(my_list)
#将lua插入到第四个元素
my_list.insert(3,‘lua’)
print(my_list)
mylist = [‘python’,‘swift’,‘lua’,‘kotlin’,‘js’]
del mylist[2]#删除第3个元素
print(mylist)
del mylist[4:7]# 删除第5个到第7个元素
del mylist[2：6：2]#指定步长

my_list = [‘python’,‘swift’,‘lua’,‘kotlin’,‘js’]
my_list[-2] = ‘java’#对单个元素赋值
print(my_list)
#被替换部分只有2个元素，替换成4个元素，实际是增加了元素
my_list[2:4] =[‘lua’,‘java’,‘go’,‘erlang’]
print(my_list)
#被替换部分只有3个元素，替换成1个元素，实际是删除了元素
my_list[2:5] = [‘objective_c’]
print(my_list)
#当对列表一段赋值时，程序会自动把字符串当成列表处理
my_list[1:3] = ‘fkjava’
print(my_list)

#字典中的数据就是key:value成对出现
#列表中的元素可增删改！字典中key-value对也可增删改！
scores = {‘语文’:85,‘数学’:92,‘英语’:89}
print(scores)
#通过key来访问value
print(scores[‘语文’])
#对不存在的key赋值，就是添加key-value对
scores[‘生物’] = 96
#对已有的key赋值，就是替换key-value对
#删除key-value对
del scores[‘数学’]
#要求每个元素只能有两个元素，其中第一个元素是key，第二个元素是value
mydict = dict([(‘语文’,88),(‘数学’,98),(‘英语’,89)])
print(mydict)
#用关键字参数来创建dict，此时不允许使用表达式
my_dict = dict(语文=88,数学=98,英语=89)
print(my_dict)

scores = {‘语文’:85,‘数学’:92,‘英语’:89}
#用一个字典(字典，序列，关键字参数)来更新原有的字典：对于已有的key，是更新value；对于不存在的key，就是添加key-value
scores.update({’语文’:89,‘生物’:94})
#使用序列作为参数，此时序列的每个元素都只能有2个元素：第1个是key，第二个是value
scores.update([(‘语文’,88),(‘物理’,92)])
#使用关键字参数，不支持用表达式
scores.update(语文=84,化学=93)
#遍历key…value…
for key in scores.keys():
print(key)
#setdefault用于获取指定key对应的value
#setdefault如果获取的key不存在时，该方法会为该key设置value
#fromkeys 方法可将序列转换成字典（使用固定的值作为value
sc = dict.fromkeys([‘语文’,‘数学’,‘英语’])
print(sc)
sc2 = dict.fromkeys([‘语文’,‘数学’,‘英语’]，60)
print(sc2)
#用元组来格式化字符串，所以它根据位置来填充“占位符”
#用dict来格式化字符串，所以他根据key来填充“占位符”
s2 = ‘图书名为：%(name)s,价格为：%(price)10.2f’;
print(s2 % ({‘price’:128,‘name’:“疯狂python讲义”})

#生成n个随机的大写字符存入列表
num = 1
import random
for i in range（num）：
#生成65-91（不包括）的随机数
n = random.randint(65,91)
#随机数转成字符，并添加到列表
result.append(chr(n))
print(result)

#列表推导式
#chr(random.randint(65,91))表达式负责生成随机的大写字符
result = [chr(random.randint(65,91)) for i in range(num)]

#numpy.random.randint()函数可生成一个随机的矩阵，可生成多行、多列的随机数
num = 10
import numpy
#numpy.random.randint(65,90,[num ,1])生成1列、num行个随机数（相当于一个包含num个随机数的列表）
result = [ chr (i) for i in numpy.random.randint(65,90,[num,1])]
print(esult)

import random
#使用列表推导式来创建一个包含重复元素的列表
src_list = [random.randint(20,30) for i in range(15)]
print(src_list)
#用新列表收集：只收集不重复的元素
target_list = []#空列表
#遍历原列表中每个元素
for ele in src_list:
#如果新列表不包含当前元素，新列表添加该元素即可,保证重复的元素在第一次添加进去之后，第二次就添加不进去了
if ele not in target_list:
target_list.append(ele)
print(target_list)

src_list = [random.randint(20,30) for i in range(15)]
print(src_list)
#将原列表传给set集合，自动去除重复元素
#再次恢复成列表
target_list = list(set(src_list))
print(target_list)
#首先必须对列表进行排序
src_list.sort()
#进行分组（相同的元素就分成同一组）
it = itertools.groupby(src_list)
#遍历各组，因此得到的都时不同的元素（去重）
for k,g in it:
print(k,end = " ")