'''
【课程3.1】序列通用操作

序列分为str list tuple

通用操作
可变且有序 list 
不可变且有序 str tuple
'''

'\n【课程3.2】  序列通用操作\nstr list tuple dict（set）\n可变且有序 list \n不可变且有序 str tuple\n可变且无序dict(set)\n同时含有key和value对 dict\n'

# 判断值是否属于序列即成员运算符

lst = [1,2,3,4,5,6]
a,b=1,9
print(a in lst)  # a 在 lst 序列中 , 如果 x 在 y 序列中返回 True。
print(b not in lst)  # b 不在 lst 序列中 , 如果 x 不在 y 序列中返回 True。

True
True

# 序列链接与重复

lst1 = [1,2,3]
lst2 = ['a','b','c']

# a+b实现序列连接，严格遵守a在前b在后
print(lst1+lst2)

#注 lst1.append（a）方法将a当作一个元素插入到列表最后
lst1.append(lst2)
print(lst1)

#区别
# +不改变原来lst1，lst2而是在缓存区产生一个新的lst
# append（）直接改变lst1

#a*n实现序列重复
print(lst1*3,lst2*2)

[1, 2, 3, 'a', 'b', 'c']
[1, 2, 3, ['a', 'b', 'c']]
[1, 2, 3, ['a', 'b', 'c'], 1, 2, 3, ['a', 'b', 'c'], 1, 2, 3, ['a', 'b', 'c']] ['a', 'b', 'c', 'a', 'b', 'c']

# 下标索引

lst = [1,2,3,4,5,6,7,8,9,0]
# 索引从0开始，eg lst[2]中，下标索引是2，指向lst的第3个值
print(lst[0],lst[2],lst[9]) 

# 索引-1代表最后一个值(-代表倒数的意思)
print(lst[-1]) 

#报错print(lst[10])  # 这里一共有10个值，所以最大索引是9

1 3 0
0

# 切片&步长
#x=lst[a:b:c]和键值对赋值相同使用：来分割参数
#a代表切片起点 b代表终点 [ )切片规则左闭右开
#c代表步长
lst = [1,2,3,4,5,6,7,8,9,0]
print(lst[0:5:2])
print(lst[:8:3])
print(lst[1::4])

[1, 3, 5]
[1, 4, 7]
[2, 6, 0]

# 序列的基本内置全局函数(用时百度)
#len sum max min 
#index返回该元素在序列中的！第一个！下标 
#count（数数）计算该值出现的次数

lst = [1,2,3,4,5,6,7,8,9,0]
print(len(lst))  # 列表元素个数
print(max(lst),min(lst),sum(lst))  # 返回列表的最大值、最小值、求和，这三个函数都只针对数字的list
print(lst.index(3))  # .index(obj)方法：从列表中找出某个值第一个匹配项的索引位置

lst = [1,1,2,3,3,4,4,4,4,5,6]
print(lst.count(4))  # .count(obj)方法：计算值的出现次数

10
9 0 45
2
4

'''
小作业
① x=[1,2,3,1,[1],[1,1]]，请问x.count(1)为多少？
② x=[1,2,5,1,“1”，“1”]，请问x.count(1)为多少？
③ y=[45,67,89,45,34,22,1],请问y.index(45)等于多少？
④ 创建一个列表，用type函数判断list[1]和list[2:5]的区别

ans
① 2 
② 2
③ 0 注返回第一个下标
④ list[1]是该元素的类型 list[2:5]切片产生子list类型依然为list
'''

'\n小作业\n① x=[1,2,3,1,[1],[1,1]]，请问x.count(1)为多少？\n② x=[1,2,5,1,“1”，“1”]，请问x.count(1)为多少？\n③ y=[45,67,89,45,34,22,1],请问y.index(45)等于多少？\n④ 创建一个列表，用type函数判断list[1]和list[2:5]的区别\n\nans\n① 2 \n② 2\n③ 0 注返回第一个下标\n'

#【课程3.2】  列表list常用操作

# 列表的特征

# 可包含任意类型的对象：数值、字符串、列表(只读列表tuple dict/set)等
lst1 = [1,2,3,'a','b','c',[1,2,3]]

# 通过下标索引访问序列中的值 → 序列的顺序是不能改变的,通过索引来定位列表的元素
lst2 = [143,56,894,67,43]
print(lst2[0],lst2[4],lst2[-1])

# 可随意变换列表长度，相当于随意指定新的列表lst3 = [1,2,3]
lst3 = lst3 * 3
print(lst3)

# 可嵌套
lst4 = [1,2,['a','b']]

# 可原位改变（不生产新列表）
lst5 = [100,101,102]
lst5[0] = 10
print(lst5)

143 43 43

'''
小作业
① [1,2,3]和[“1”, “2”, “3”]什么区别
② 创建一个列表，包括3个人的数学成绩100，89,78
③ 创建一个列表，包括5个中国城市名称
④ 现有一个列表name = ['小明', '小红'] ,增加“团支书”的名字上去
⑤ 现有一个列表m=[3.1,5.5,4,3,77,8]，用print分别输出第2、4个元素
'''

''

'''
answer
① 1是int，'1'是string
②lst1=[100,89,78]
③ 同上
④ lst.append('团支书')
⑤ print(m[1],m[3])
'''

"\nanswer\n① 1是int，'1'是string\n②lst1=[100,89,78]\n③ 同上\n④ lst.append('团支书')\n⑤ print(m[1],m[3])\n"

# 列表与生成器range()

# range()是生成器,类型就是独立的range而不是list，指向了一个范围
# range(5)代表指向了0,1,2,3,4这几个值
# range(2,5)代表指向了2,3,4这几个值，和切片相同左闭右开
# range(0,10,2)代表指向了0,2,4,6,8这几个值，最后的2代表步长
#注 range参数(起点，终点，步长)是由，连接 不像切片lst[1:5:2]是用:连接

# 通过list()函数(注意函数list()生成列表 对象list创建是list[])
lst=list(range(9))
print(lst)

[0, 1, 2, 3, 4, 5, 6, 7, 8]

'''
小作业
① range()生成的是不是都是整数?
② 创建一个range，用type()函数查看其类型
③ 哪种方式书写正确：x=range(5), x=range(4:7), x=range(4,8)
④ 创建一个range，用print输出其值，看一下输出结果
⑤ 用list()函数，将一个range范围变为列表
⑥ m=range(10),请问m[2],m[-1],m[5]是多少
'''

''

'''
小作业
① 是
② range
③ 2
④ 
⑤ 
⑥ 2 9 5
'''

'\n小作业\n① 是\n② range\n③ 2\n④ \n⑤ \n⑥ 2 9 5\n'

# 可变列表list常用操作 - 添加元素

# list.append(x) 添加元素无论x是什么类型，都当作list的最后一个元素添加
# 添加多个元素用.extend()方法：用新列表扩展原来的列表，list增加多个元素，注意和append()方法的区别
lst=list(range(10))
lst.append('hello')
print(lst)

lst.append(['a','b','c'])
print(lst)
lst.extend(['a','b','c'])
print(lst)

#注 append extend和+的区别是前者只接在当前列表上进行操作
#+在内存里先复制一个和当前lst一样的templst然后再在templst上进行操作，所以lst的值不会变
#注 append（x）x不拆括号 extend（x）x拆一层括号

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'hello']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'hello', ['a', 'b', 'c']]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'hello', ['a', 'b', 'c'], 'a', 'b', 'c']

# 可变列表list常用操作 - 删除元素

# .remove方法：移除列表中某个值的第一个匹配项
#注意remove（）第一个
lst = ['Jack','Jack','Tom','Tracy','Alex','White']
lst.remove('Jack')
print(lst)

# del语句：删除list的相应索引值对应元素
del lst[3:5]
print(lst)

# clear()方法:移除所有值
lst.clear
print(lst)

#注意以上三种方法都是直接在当前lst上操作，不会复制新的lst再操作

['Jack', 'Tom', 'Tracy', 'Alex', 'White']
['Jack', 'Tom', 'Tracy']
['Jack', 'Tom', 'Tracy']

# 可变列表list常用操作 - 插入元素
# x.insert(i,m)方法：在索引i处(从0开始)插入m，原来此处的元素和之后的元素整体往后移，这里索引3代表第四个值
lst=list(range(10))
print(lst)
lst.insert(3,'a')
print(lst)

# 插入一个列表元素
lst.insert(5,[1,2,3])
print(lst)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 'a', 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 'a', 3, [1, 2, 3], 4, 5, 6, 7, 8, 9]

# 可变列表list常用操作 - 复制

#lst1=lst只是传递引用 
#实际内存只有一份列表，lst，lst1同时指向同一个列表
lst = list(range(10))
lst1 = lst
lst1[2] = 'hello'
print(lst,lst1)

# list.copy()方法：复制一个新的列表，物理内存现在有两个相同的列表
#lst，lst2指向两个列表（虽然两个列表值相同）

# 可变列表list常用操作 - 排序

#sort（reverse=？）方法,不复制直接在原list进行排序
lst1 = [12,45,32,98,45,66,3]
lst2 = ["asd", "cxv", "ghv"]
lst1.sort()
lst2.sort()
print(lst1,lst2)

# 参数reverse：反向排序
lst1.sort(reverse=True)
lst2.sort(reverse=True)
print(lst1,lst2)

#注函数sorted():默认先复制再排序 lst1内容不变（不进行排序）
lst3 = sorted(lst1)
lst3.append('hello')
print(lst1,lst3)

[3, 12, 32, 45, 45, 66, 98] ['asd', 'cxv', 'ghv']
[98, 66, 45, 45, 32, 12, 3] ['ghv', 'cxv', 'asd']
[98, 66, 45, 45, 32, 12, 3] [3, 12, 32, 45, 45, 66, 98, 'hello']

# 讲一讲元祖tuple ：不可变的“列表”不能不进行复制直接在原tuple上改变
#eg 方法append() extend() sort() remove() (clear()可用删除tuple) 语句del 都不可用
#方法几乎（除clear（））都不用 因为方法大多希望不复制直接改变tuple

#注：tuple用（）新建
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d"  # 可以不加括号，了解即可，不要这样用

# 索引、切片和list一样用[]和[：：]
print(tup1[2],tup3[:2])

# 序列通用函数len() + * max min sum sorted 
print(len(tup1))
print(tup1 + tup2)
print(tup4 * 3)
print(max(tup2),min(tup2),sum(tup2))
print(sorted(tup2))

#list tuple相互转化
lst1=list(tup1)
tup1=tuple(lst1)
print(lst1,tup1)

1997 ('a', 'b')
4
('physics', 'chemistry', 1997, 2000, 1, 2, 3, 4, 5)
(1, 2, 5, 1, 2, 5, 1, 2, 5)
5 1 15
[1, 2, 3, 4, 5]
['physics', 'chemistry', 1997, 2000] ('physics', 'chemistry', 1997, 2000)

"""
小作业
① 分别用append、extend方法，给一个序列增加一个元素1
② x.append([1,2,3])和x.extend([1,2,3])的区别
③ x.append('abc')和x.extend('abc')的区别
④ 创建某一列表，在列表中间插入一个值
⑤ 创建一个随机数值列表，按照降序排列
⑥ sort()和sorted()什么区别
⑦ s=[32,45,63,12,45,89,77], s.remove(45), del s[2], s.pop(4)分别什么区别
⑧ m=[4,5,6,73,4,4,4,4,2]，删除2，删除所有的4
"""

"\n小作业\n① 分别用append、extend方法，给一个序列增加一个元素1\n② x.append([1,2,3])和x.extend([1,2,3])的区别\n③ x.append('abc')和x.extend('abc')的区别\n④ 创建某一列表，在列表中间插入一个值\n⑤ 创建一个随机数值列表，按照降序排列\n⑥ sort()和sorted()什么区别\n⑦ s=[32,45,63,12,45,89,77], s.remove(45), del s[2], s.pop(4)分别什么区别\n⑧ m=[4,5,6,73,4,4,4,4,2]，删除2，删除所有的4\n"

#① 注 append（x）x不拆括号 extend（x）x拆一层括号
lst = [1,2,3]
lst.append(1)
print(lst)
lst.extend([1])
print(lst)

[1, 2, 3, 1]
[1, 2, 3, 1, 1]
[1, 2, 3, 1, 1, '1', '2', '3', '123']

#② x.append([1,2,3])将lst[1,2,3]当作一个元素插到x最后
#x.extend([1,2,3])拆掉[]将1，2，3插入到x后面
lst = [1,2,3]
lst.extend([1,2,3])
lst.append([1,2,3])
print(lst)

[1, 2, 3, 1, 2, 3, [1, 2, 3]]

#③ x.append('abc')将'abc'整个string作为一个元素插到x最后
#x.extend('abc')将‘abc’拆为‘a’‘b’‘c’三个独立string插到x最后
lst = [1,2,3]
lst.extend('123')
lst.append('123')
print(lst)

[1, 2, 3, '1', '2', '3', '123']

#⑤用numpy

#⑥ lst1.sort()方法不复制直接排序
#lst2=sorted(lst1)复制排序 lst1值不变

s=[32,45,63,12,45,89,77]
y=s.remove(45)  
print(s,y)

s=[32,45,63,12,45,89,77]
del s[2:5:2]  
print(s)

s=[32,45,63,12,45,89,77]
x=s.pop(4)
print(s,x) 

"""
注
remove()输入为要删除的数值而不是index，且无返回值
del 输入为删除的index且可以起点终点步长的方式删除
pop()出栈 输入为index且返回此值
"""

[32, 63, 12, 45, 89, 77] None
[32, 45, 12, 89, 77]
[32, 45, 63, 12, 89, 77] 45





'\n注\nremove()输入为要删除的数值而不是index，且无返回值\ndel\n'

'''
【课程3.3】  文本序列str常用操作

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串
字符串也是序列：文本序列

'''

'\n【课程3.3】  文本序列str常用操作\n\n字符串是 Python 中最常用的数据类型。我们可以使用引号(\'或")来创建字符串\n字符串也是序列：文本序列\n\n'

# 字符串引号

# 双引号单引号无区别，但文本中有引号的时候要相互交替使用
str1 = "abc"
str2 = 'abc'
str3 = 'my name is "fatbird"'

# 需要多行字符串时候用三引号 ''' ''',""" """
str4 = '''hello! how are you?
          I`m fine, thank you.'''

# 转义字符：\

#分别输出单引号，双引号,用上小节""  ''交替的方法也可以 
#但是如果层次很多没有\'直接转义方便，因为此方法不要求单双必须隔开
print('\'', "\"")  # \',\" 
# \n：空行
print('hello\nhow do you do?')  
# 输出\，所以文件路径用“/”或者“\\”或者加r'\'
print('/')
print('\\')  
print(r'\n')

' "
hello
how do you do?
/
\
\n

# 序列通用功能
#成员运算 in/not in ：判断是否存在
print('a' in 'abc')

# 文本连接,注意python的a+b文本连接要求a，b必须同str
#存在类型不同的变量连接需要强制类型转换str()
print('a'+str(2))

# 文本复制
print('2'*32)

# 索引、切片、步长
st = 'abcdefg'
print(st[2],st[-1])
print(st[:2])
print(st[::2])

# .index()方法
print(st.index('g'))

# 计算字符串长度（思考这里能否把逗号换为"+"）
print('st长度为：',len(st))
#不可 python的a+b文本连接要求a，b必须同str，可以强类型转换
print('st长度为：',str(len(st)))

True
a2
22222222222222222222222222222222
c g
ab
aceg
6
st长度为： 7
st长度为： 7

# 字符串常用功能

# str.replace(old,new,count)：修改字符串，count：从前往后更换几个
#注意str.replace()方法返回值是新的字符串，而且是复制改变，即原来的字符串不变
st = "i am handsome"
st2 = st.replace('handsome',"smart")
print(st)
print(st2)

st = 'hahaha'
st2 = st.replace('ha','he',2)
print(st)
print(st2)

# str.split(obj)：拆分字符串，生成列表
st = "poi01,116.446238,39.940166"
lst=st.split(',')
print(lst)

# str.join()：将列表通过字符串1连接字符串2，字符串1.join(输入)为列表
#复制改变 字符串1不变
lst = ['poi01', '116.446238', '39.940166']
m = '-'
st = m.join(lst)
print(st)
print(m)

# str.startswith(“str”)  判断是否以“str”开头
#str.endswith (“str”)  判断是否以“str”
st = 'abcdefg'
print(st.startswith('a'), st.endswith('f'))

st = 'aBDEAjc kLM'
print(st.upper())  # 全部大写
print(st.lower())  # 全部小写
print(st.swapcase())  # 大小写互换
print(st.capitalize())  # 首字母大写

# 如果 string 只包含数字则返回 True,否则返回 False.
st='1529'
print(st.isnumeric())

# 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
st='gfg'
print(st.isalpha())

# 删除str两端空格
#lstrip() left
#rstrip() right
#strip() both
st = '  avd   '
print(st.lstrip())
print(st.rstrip()) 
print(st.strip())

i am handsome
i am smart
hahaha
heheha
['poi01', '116.446238', '39.940166']
poi01-116.446238-39.940166
-
True False
ABDEAJC KLM
abdeajc klm
AbdeaJC Klm
Abdeajc klm
True
True
avd   
  avd
avd

# 格式化字符：在字符串中插入变量 法一：两个%法
# %s %z %f %g %e都是格式化字符串
#s/i/f/g/e分别代表插入字符串的源数据类型：整型/字符型/浮点型/浮点型自动识别科学记数法/科学记数法
x=4
y='hehe'
z=4.2
#注意第二个%前不需要，（不需要小三来插足）
print('this is %i'%x)
print('this is %s'%y)
print('this is %f'%z)

this is 4
this is hehe
this is 4.200000

# 格式化字符：数字格式化的那些坑

# %.2f .2表示保留小数点后两位数字 且%f为四舍五入！
m=3.151526
print("m = %f"%m)
print("m = %.2f"%m)

m = 3.151526
m = 3.15

#去掉小数部分两种方法
#%i 去尾法
#%.0f 四舍五入法
#字符串里有多个前# 后#(v1,v2,v3)
m=10.6
print('m = %.0f,%i'%(m,m))

m = 11,10

#+加到最前面 +.2f显示正号，负号根据数字直接显示
m=134.345456
n=-2334.45
print("m = %+.2f"%m)
print("n = %.2f"%n)

m = +134.35
n = -2334.45

# 空格加到最前面，无论加几个，空格和+都只能显示一个，且+优先级高
m=134.345456
print("m = %              .2f"%m)
print("m = %  ++     .2f"%m)
print("m = %       .2f"%-0.22225648)

m =  134.35
m = +134.35
m = -0.22

# 科学计数法 %e  %E
m = 123.123123123 
print("have fun %.2e"  %m)
print("have fun %.4E"  %m)

have fun 1.23e+02
have fun 1.2312E+02

# %g小数位数少的时候自动识别用浮点数，数据复杂的时候自动识别用科学计数法
m1=344444444444444.4345452515262552626
m2=23.2
print("have fun %g"  %m1)
print("have fun %g"  %m2)

have fun 3.44444e+14
have fun 23.2

# 更强大的格式化方法.format配合{}占位符法

# {} 代表占位符，其中可以有数字明确指定参数也可以没有
#但是如果没有数字{}数量必须和format()里参数个数相同
print('{}{:2f}{:d}'.format('a',2.3696559,5)+'\n'+
     '{1}{2}{1}{1}'.format('2','3',0))

a2.3696565
3033

# 也可以用跨度仅为一句的临时变量来指示
#注意对临时变量work的赋值必须在format()里面
print("我的工作是{work}".format(work = '设计'))

我的工作是设计

#注意str.format()生成新的字符串，原来的str不变
x='2324{}'
a=x.format('52656')
print(x,a)

2324{} 232452656

#format的字母代表和两个%方法大致一样
#区别1法二在{：}最前面要加：
# 2法二{:d}代表int 法一%i
#法二{：%}可以进行百分数换算输出
print("{:f}".format(4.123),'\n',
 "{:.2f}".format(4.123),'\n',
 "{:e}".format(4.123),'\n',
 "{:.0f}".format(99.9),'\n',
 "{:%}".format(4.123),'\n',
 "{:d}".format(10))

4.123000 
 4.12 
 4.123000e+00 
 100 
 412.300000% 
 10

"""
小作业
① 三引号创建一个有提行的文本，print()函数输出
② 申明一个字符串变量，值为一个文件路径，注意操作习惯
③ 以下输出分别是多少：33+"22"; 33+int("22"); "22" + str(55); 
④ m=“a,b,c”,m.split()会输出什么结果？（不加","）
⑤ 再回想一下：.split和.join的输出分别是什么类型的数据
⑥ 如果我想打%怎么办？
⑦ 这样书写正确吗，为什么？ print("abc%s") % "nn"
⑧ 这样书写正确吗，为什么？ print(245%f % 123)
⑨ "我的工作是…我喜欢…" 把…替换成正确的内容 
"""

'\n小作业\n① 三引号创建一个有提行的文本，print()函数输出\n② 申明一个字符串变量，值为一个文件路径，注意操作习惯\n③ 以下输出分别是多少：33+"22"; 33+int("22"); "22" + str(55); \n④ m=“a,b,c”,m.split()会输出什么结果？（不加","）\n⑤ 再回想一下：.split和.join的输出分别是什么类型的数据\n⑥ 如果我想打%怎么办？\n⑦ 这样书写正确吗，为什么？ print("abc%s") % "nn"\n⑧ 这样书写正确吗，为什么？ print(245%f % 123)\n⑨ "我的工作是…我喜欢…" 把…替换成正确的内容 \n'

"""
2三种方法

3错 55 2255

4['a,b,c']不进行切片当作一大片放入list

5
str.split in：str out：list
str2=str.join（list1） in str list1 out str2

6
print('sdse%%d%% %i'%2)
out:
sdse%d% 2
连续两个%输出一个%

7不正确%'nn'要放在print（）里
print("abc%s"% "nn") 

8不正确 第一个%x要在print('')的''里
print("245%f" % 123)

9
print('我的工作是%s我喜欢%s'%('程序员','成为技术大佬'))
"""

"\n2三种方法\n\n3错 55 2255\n\n4['a,b,c']不进行切片当作一大片放入list\n\n5\nstr.split in：str out：list\nstr2=str.join（list1） in str list1 out str2\n\n6\nprint('sdse%%d%% %i'%2)\nout:\nsdse%% 2\n连续两个%\n\n"