20天小白学python day3

一、字符串及常用方法

1、字符串常用方法

2、切片操作

• 切片是指截取字符串中的其中一段内容。
• 切片使用语法：[起始下标：结束下标：步长]
• 切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符。

3、与其他类型综合操作

Test='python'
print(type(Test))
print('获取第一个字符%s'%Test[0])
print('获取第二个字符%s'%Test[1])
for item in Test:
    print(item,end=' ')

name='peter'
print('姓名首字母转换大写%s'%name.capitalize()) capitalize 首字母变大写
a='     hello       '
b=a.strip() #去除字符串中两边的空格
print(a)
print(a.lstrip()) #删除左边的空格
print(a.rstrip()) #删除右边的空格

# 复制字符串
print('a的内存地址%d'%id(a)) #id函数 可以查看一个对象的内存地址
b=a #在此只是把a对象的内存地址赋给了b
print('a的内存地址%d'%id(a))
print(b)
dataStr='I love Python'
print(dataStr.find('M')) #find函数可以查找目标对象在序列对象中的为值,如果没找到就返回-1
print(dataStr.index('W')) #检测字符串中是否包含子字符串 返回的是下标值
index如果没有找到对象的数据 便会报异常，而find函数不会，找不到返回-1
print(dataStr.startswith('I'))  #判断开头
print(dataStr.endswith('n'))#判断结尾

print(dataStr.lower()) #转换成小写
print(dataStr.upper())#转换成大写

strMsg='hello world'
slice [start:end:step] 左闭右开  start<=value<end 范围
print(strMsg) #输出完整的数据
print(strMsg[0])
print(strMsg[2:5]) #2-5下标之间的数据
print(strMsg[2:]) #第三个字符到最后
print(strMsg[:3]) #1-3    strMsg[0:3]=strMsg[:3]
print(strMsg[::-1]) #倒叙输出  负号表示方向  从右边往左去遍历

二、列表及常用方法

1. 创建一个列表，只要把逗号分隔的不同的数据项使用**[方括号括]**起来即可。
2. 列表的下标取值/切片/是否越界与字符串一致，区别就是列表是获取元素。
3. 用for循环可将列表中的元素一个一个取出，取完后退出循环。

li=[] #空列表
li=[1,2,3,"你好"]
print(len(li)) #len函数可以获取到列表对象中的数据个数
strA='我喜欢python'
print(len(strA))
print(type(li))

# 查找
listA=['abcd',785,12.23,'qiuzhi',True]
print(listA) #输出完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #从第二个开始到第三个元素
print(listA[2:]) #从第三个元素开始到最后所有的元素
print(listA[::-1]) #负数从右像左开始输出
print(listA*3) #输出多次列表中的数据【复制】

print('--------------增加-----------------------')
print('追加之前',listA)
listA.append(['fff','ddd']) #追加操作
listA.append(8888)
print('追加之后',listA)
listA.insert(1,'这是我刚插入的数据') #插入操作 需要执行一个位置插入
print(listA)
rsData=list(range(10)) #强制转换为list对象
print(type(rsData))
listA.extend(rsData) #拓展  等于批量添加
listA.extend([11,22,33,44])
print(listA)

print('-----------------修改------------------------')
print('修改之前',listA)
listA[0]=333.6
print('修改之后',listA)
listB=list(range(10,50))

print('------------删除list数据项------------------')
print(listB)
del listB[0] #删除列表中第一个元素
del listB[1:3] #批量删除多项数据 slice
listB.remove(20) #移除指定的元素  参数是具体的数据值
listB.pop(1) #移除制定的项  参数是索引值
print(listB)

print(listB.index(19,20,25))  #返回的是一个索引下标

• append 在列表后面追加元素
• count 统计元素出现的次数
• extend 扩展，相当于批量添加
• index 获取指定元素索引号
• insert 在指定位置插入
• pop 删除最后一个元素
• remove 移除左边找到的第一个元素
• reverse 反转列表
• sort 列表排序reverse=True 倒序

三、元组

1>定义

• 元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，元组也是通过下标进行访问
• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

2>方法

• 元组的内置方法count，统计元素在元组中出现的次数
• 元组的内置方法index 查找指定元素在元组中的下标索引

# 元组的创建 不能进行修改
tupleA=() #空元组
# print(id(tupleA))
tupleA=('abcd',89,9.12,'peter',[11,22,33])
print(id(tupleA))
print(type(tupleA))
print(tupleA)

#元组的查询
for item in tupleA:
    # print(item,end=' ')
print(tupleA[2:4])
print(tupleA[::-1])

print(tupleA[::-2]) #表示反转字符串 每隔两个去一次
print(tupleA[::-3]) #表示反转字符串 每隔三个去一次
print(tupleA[-2:-1:]) #倒着取下标 为-2 到 -1 区间的
print(tupleA[-4:-2:]) #倒着取下标 为-2 到 -1 区间的

tupleA[0]='PythonHello'  #错误的
tupleA[4][0]=285202  #可以对元组中的列表类型的数据进行修改
print(tupleA)
print(type(tupleA[4]))

tupleB=('1',) # 当元组中只有一个数据项的时候，必须要在第一个数据项后面加上 逗号
# print(type(tupleB))
tupleC=(1,2,3,4,3,4,4,1)   #tuple(range(10))

print(tupleC.count(4)) #可以统计元素出现的次数

四、字典及常用方法.

1>什么是字典

• 字典是Python的中重要的一种数据类型，可以存储任意对像。
• 字典是以键值对的形式创建的{‘key’:‘value’}利用大括号包裹着。
• 字典中找某个元素时，是根据键、值字典的每个元素由2部分组成，键:值
• 访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

注意点：

1. 字典的键（key）不能重复，值（value）可以重复。
2. 字典的键（key）只能是不可变类型，如数字，字符串，元组。

2>
新增元素：如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
修改元素：字典中的值是可以修改的，通过键找到对应值修改
删除元素：del 删除指定元素 clear 清空字典.
获取键：keyspython3中返回包含字典所有key值的dict_keys对象，用for循环取出每个key值。
删除指定健：pop(‘健’) 删除指定键
获取键值对：python3 返回一个包含所有（键，值）元祖的列表dict_items对象
统计个数：len() 可以查看字典中有几个键值对
获取值：values python3版本中使用values返回一个包含所有值（value）的dict_values对象

# 如何创建字典
dictA={"pro":'艺术','shcool':'北京电影学院'} #空字典

# 添加字典数据
dictA['name']='张大三'  #key:value
dictA['age']='30'
dictA['pos']='歌手'

#结束添加
print(dictA) #输出完整的字典
print(len(dictA))  #数据项长度
print(type(dictA))

print(dictA['name']) #通过键获取对应的值
dictA['name']='谢霆锋'  #修改键对应的值
dictA['shcool']='香港大学'
dictA.update({'height':1.80}) #可以添加或者更新
print(dictA)

# 获取所有的键
print(dictA.keys())
# 获取所有的值
print(dictA.values())
# 获取所有的键和值
print(dictA.items())
for key,value in dictA.items():
    print('%s==%s'%(key,value))

# 删除操作
del dictA['name']  通过指定键进行删除
dictA.pop('age')   通过指定键进行删除
print(dictA)

# 如何排序 按照key排序
print(sorted(dictA.items(),key=lambda d:d[0]))
# 按照value排序
print(sorted(dictA.items(),key=lambda d:d[1]))

#字典拷贝
import copy
# dictB=copy.copy(dictA) #浅拷贝
dictC=copy.deepcopy(dictA) #深拷贝
print(id(dictC))
print(id(dictA))
# dictB['name']='peter'
dictC['name']='李四'
print(dictC)
print(dictA)

五、共有操作

1. 合并操作：+两个对象相加操作，会合并两个对象（适用于字符串，列表，元组 ）

# 字符串合并
strA='人生苦短'
strB='我用Python'
# list 合并
listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)

2. 复制：对象自身按指定次数进行 + 操作（适用于字符串，列表，元组）

# 复制 *
strA='人生苦短'
strB='我用Python'
print(strA*3)
print(listA*3)

3. in 判断元素是否存在：判断指定元素是否存在于对象中（适用于字符串,列表,元组,字典）

# in  对象是否存在 结果是一个bool值
print('我' in strA) #False
print(9 in listA)  #False
dictA={"name":"peter"}
print("name" in dictA)