Python Day03

序列

定义：按照顺序排列的值

类型：字符串，列表，元组

优点：支持索引和切片的操作

特征：第一个正索引为0，指向的是左端；第一个索引为负数的时候，指向的是右端

字符串string

下标

：字符串中从左往右依次编号

切片

：截取字符串中的任意一段内容

• 使用方法：[起始下标：结束下标：步长]
• 左包含，右不包含
• 步长指隔几个下标取一个字符，步长默认为一
• 三个部分都可省略其中任意两个
• 从0开始
• 一旦改变开辟新的内存空间

Test='hello world'
# print(type(Test))
print('第一个字符%s'%Test[0])
print('第二个字符%s'%Test[1])
for item in Test:
    print(item,end=' ')
print()
print(Test[2:5])
print(Test[2:])
print(Test[0:7:2])#隔2个取的是2的末尾，不是2的下一个
print(Test[:3])
print(Test[::-1])#倒叙输出

常用语法

1. 首字母变大写

name='peter'
print('姓名首字母转换大写%s'%name.capitalize())

2. 去空格

a='   hello     '
print(a.strip())#删除左右空格
print(a.lstrip())#删除左空格
print(a.rstrip())#删除右空格

3. 复制字符串

a='hello'
b=a#把a的内存地址赋给b
print('a的内存地址%d'%id(a))
print('b的内存地址%d'%id(b))
print(b)

4. 查找x是否在字符串

dataStr='i love python'
print(dataStr.find('p'))
#返回下标值7
#只执行一次，重复的只指出第一个
#不存在返回-1
print(dataStr.index('p'))
#返回下标值7
#不存在直接报错

5. 判断一个字符串是否以某个字符串开头结尾

dataStr='ilove python'
print(dataStr.startswith('il'))
print(dataStr.endswith('on'))

6. 大小写转换

dataStr='i love python'
print(dataStr.lower())
print(dataStr.upper())

列表list

：一种数据结构，有序的数据集合

1. 可随时增删改查等
2. 列表中数据可以变化（数据项可变化，内存地址不会改变）
3. 用[]表示列表类型，数据项之间用逗号来分割（数据项可以是任何类型数据）
4. 支持索引和和切片
5. 可用for循环遍历

常用语法

1. 定义列表

li=[]#空列表
li=[1,2,3,'hello']
print(len(li))#4
print(type(li))#list

2. 切片

listA=['abcd',785,12.23,'qiuzhi',True]
print(listA)#输出完整列表
print(listA[0])#输出单个数据项
print(listA[1:3])#输出区间范围数据
print(listA[2:])#从第三到最后
print(listA[::-1])#倒叙
print(listA*2)#输出多次数据（复制）

3. 查找

listA=['abcd',785,12.23,'qiuzhi',True]
print(listA.index(785,0,6))#返回索引下标，第二个数：从第几个开始查，第三个数：查找长度

4. 添加

listA=['abcd',785,12.23,'qiuzhi',True]
print(listA)
listA.append(['fff','ddd'])#追加（整个对象，整体打包，有中括号）
print(listA)
listA.insert(1,'这是我刚插入的数据')#选定第二个后面插入数据
print(listA)
rsDate=list(range(10))#强制转换为list对象
listA.extend(rsDate)#批量追加（序列，两序列合并，无中括号）
print(listA)


# ['abcd', 785, 12.23, 'qiuzhi', True]
# ['abcd', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd']]
# ['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd']]
# ['abcd', '这是我刚插入的数据', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4. 修改（先找后修）

listA=['abcd',785,12.23,'qiuzhi',True]
listA[0]='peter'
print(listA)

5. 删除

listA=['abcd',785,12.23,'qiuzhi',True]
del listA[0]
print(listA)
del listA[1:3]#批量删除（切片），在上面删除后的基础下
print(listA)
listA.remove(785)#移除指定元素，不加''，参数是具体的数据
print(listA)
listA.pop()#移除指定项，参数是索引值
print(listA)

del和pop区别：https://www.zhihu.com/question/56352653

元组tuple

：不能修改的列表

1. 使用小括号，数据项用逗号分隔
2. 不可变，内嵌的列表可以修改
3. 可以是任何类型
4. 当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理
5. 支持切片操作

常用语法

1. 创建

   tupleA=()#空元组
   tupleA=('abcd',89,9.12,[11,22,33])
   #上面两个内存地址不一样
   print(type(tupleA))
   print(tupleA)
   
   tupleA=(1)
   print(type(tupleA))#int
   tupleB=(1,)#加逗号
   print(type(tupleB))#tuple
   

2. 查询（切片）

   tupleA=('abcd',89,9.12,'peter',[11,22,33])
   for item in tupleA:
       print(item,end=' ')
   print()
   print(tupleA[2])
   print(tupleA[2:4])
   print(tupleA[::-1])#从右往左:-1，-2，-3，-4......
   print(tupleA[-2:-1])#取的时候从左往右取      ('peter',)含有逗号
   print(tupleA.index(89))#1
   

3. 修改（只能对里面的列表修改）

   tupleA=('abcd',89,9.12,'peter',[11,22,33])
   tupleA[4][0]=123#两个[]
   print(tupleA)
   

4. 统计字符出现的次数（count）

   tupleA=(1,2,3,4,5,6,7,1,2,1,2)
   print(tupleA.count(1))
   

字典

：数据类型，是由键值对组成的集合，通常使用键来访问数据，效率高

1. 支持增删改查
2. 不是一个序列类型->五下标（无序）->不能用索引
3. 用{}来表示，每个数据项用逗号分隔
4. 键必须是不可变的类型（元组，字符串），值可以是任意类型
5. 每个键必定唯一，如果存在重复的键，后者覆盖前者

常用语法

1. 创建

   dictA={}#空字典
   print(type(dictA))
   

2. 添加

   dictA={'pro':'art','school':'beijing'}
   dictA['name']='Jack'#中括号中：键（key）   等号右边：值（value）
   dictA['age']=30
   dictA['work']='singer'
   print(len(dictA))#数据项长度
   dictA.update({'height':32})
   print(dictA)
   

3. 查找

   dictA={'pro':'art','school':'beijing'}
   dictA['name']='Jack'
   dictA['age']=30
   dictA['work']='singer'
   
   print(dictA['name'])#通过键获取对应的值
   

4. 修改

   dictA={'pro':'art','school':'beijing'}
   dictA['name']='Jack'
   dictA['age']=30
   dictA['work']='singer'
   
   dictA['name']='peter'
   print(dictA)
   dictA.update({'age':32})
   print(dictA)
   

5. 获取所有键或值

   dictA={'pro':'art','school':'beijing'}#空字典
   dictA['name']='Jack'#中括号中：键   等号右边：值
   dictA['age']=30
   dictA['work']='singer'
   
   print(dictA.keys())#键
   print(dictA.values())#值
   print(dictA.items())#键值对
   for item in dictA.items():
       print(item)#遍历
   for key,value in dictA.items():
       print('%s=%s'%(key,value))
   

6. 删除

   dictA={'pro':'art','school':'beijing'}#空字典
   dictA['name']='Jack'#中括号中：键   等号右边：值
   dictA['age']=30
   dictA['work']='singer'
   
   del dictA['name']
   dictA.pop('age')
   print(dictA)
   

7. 排序

   dictA={'pro':'art','school':'beijing'}#空字典
   dictA['name']='Jack'#中括号中：键   等号右边：值
   dictA['age']='30'
   dictA['work']='singer'
   
   #按key
   print(sorted(dictA.items(),key=lambda d:d[0]))
   #按value
   print(sorted(dictA.items(),key=lambda d:d[1]))#数据类型要一样，字符串根据阿斯克码来排序
   

公用方法

+合并操作

（字符串，列表，元组）

strA='hello'
strB=' world'
listA=list(range(10))
listB=list(range(11,20))
print(strA+strB)
print(listA+listB)

*复制

（字符串，列表，元组）

strA='hello'
strB=' world'
listA=list(range(10))
listB=list(range(11,20))
print(strA*3)
print(listA*3)

in判断元素是否存在

（字符串，列表，元组，字典）

strA='hello'
strB=' world'
listA=list(range(10))
listB=list(range(11,20))
dictA={'name':'peter'}
print('he' in strA)
print(2 in listA)
print('name' in dictA)

注释

• 字符串中单引号双引号都可以
• 按回车可打出提示
• id函数可查看内存地址
• len函数可获取数据个数
• 一定要加单引号
• 数据名称不用加引号
• 倒叙：从右往左:-1，-2，-3，-4…