Python-数据对象
一、字符串基础
1.字符串可以用双引号 、 单三引号、双三引号
"你好"
'''你好'''
# 三引号，直接写内容多行
"""你好"""
2.使用转义符号换号
# \n换行，\t一个tab、\\将后面的转义字符转为普通字符
word = 'hello world \n'
# 自然字符串:使用R、r来表示
r"ASDF\\"
3.字符串拼接
myFavorit = '我最爱的运动是：'
sport = '足球'
print(myFavorit + sport)
4.字符串元素索引
hello = '小明你好啊'
# 输出'小'
print(hello[0])
# 输出'啊'
print(hello[-1])
5.字符串切片
hello='刘总你好啊'
# '刘总'
print(hello[0:2])
print(hello[:2])
print(hello[-5:-3])
# '你好啊'
print(hello[2:5])
print(hello[-3:])
#print(hello[-3:-1]) ？最后一个怎么切
print(hello[-1])
6.获取字符串长度
# len 为内置函数，计算字符串长度
var = '中国人民永垂不朽'
var_len = len(var)
print(var_len)
二、字符串的方法
1.字符串增
a = "123"
b = "456"
c = a + b
2.字符串改
split从字符串截取想要的信息-私不勒特
split方法以参数字符串为分割符 ，将字符串切割为多个字符串，作为元素存入一个列表，并返回这个列表
str1 = '小张：79 | 小李：88 | 小赵：83'
qie=str1.split('|')
print(qie)
# ['小张：79 ', ' 小李：88 ', ' 小赵：83']
print(str1)
# 小张：79 | 小李：88 | 小赵：83
splitlines把字符串按换行符进行切割
# \继续输入的意思
str1 = \
'''
小张：79
小李：88
小赵：83
'''
qie=str1.splitlines()
print(qie)
# ['', '小张：79 ', '小李：88 ', '小赵：83']
# 切割的第一个为空的原因是，'''造成的
join将列表中的字符串元素以某字符串为连接符， 连接为一个字符串
word='|'.join([
'小张：79 ',
' 小李：88 ',
' 小赵：83'
])
print(word)
# 小张：79 | 小李：88 | 小赵：83
strip/lstrip/rstrip将字符串前面和后面的空格删除，但是不会删除字符串中间的空格
strip
#返回的就是 '小 李：88'，去掉了前后的空格，但是中间的空格不会去掉
' 小 李：88 '.strip()
lstrip方法将字符串前面 (左边) 的空格删除，但是不会删除字符串中间和右边的空格
# 返回的就是 '小 李：88 '
' 小 李：88 '.lstrip()
rstrip方法将字符串右边的空格删除，但是不会删除字符串中间和左边的空格
# 返回的就是 ' 小 李：88'
' 小 李：88 '.rstrip()
replace替换
# '他们今天不去上学，他们踢足球'
str1 = '我们今天不去上学，我们去踢足球'
str1 = str1.replace('我们', '他们')
字符串的倒序
# :: 表示切片字符串的从头到尾，也就是全部内容
# -1 表示，颠倒过来取元素
str1 = '字符串的倒序'
reverse = str1[::-1]
print(reverse)
字符串大小写
# 将每个单词的首字母改为大写
str.title()
# 将字符串全部改为大写
str.upper()
# 将字符串全部改为小写
str.lower()
3.字符串删
字符串本身是不能修改的，但是可以通过其他方法来达到一个看似修改的效果
比如，切片+拼接 replace()替换，strip(), rstrip(),lstrip()去掉两端的字符
4.字符串查
index查找
# 返回序列s中x元素所在的索引值是多少
S.index("x")
# 指定范围，返回序列s中x元素所在的索引值是多少
S.index(start,end,"x")
S.index(0,7,"x")
find会在字符串中查找参数，并返回该参数字符串在其中第一个出现的位置索引
str1 = '我们今天不去上学，我们去踢足球'
# 返回 0 ， str1字符串中有两个 '我们'
# find返回的是第一个 '我们' 的索引 0
# 如果字符串对象里面 没有 要查找的参数字符串，就会返回 -1
pos1 = str1.find('我们')
find指定查找字符串范围
str1 = '我们今天不去上学，我们去踢足球'
# 第2个参数 5， 表示从 索引5 的位置开始往后查找
# ！！！！索引正常数数的右边！！！！！！
# 返回的是后面 我们 的索引 9
pos1 = str1.find('我们',5)
startswith 和 endswith检查字符串是否以指定参数开头/结尾
str1 = '我们今天不去上学，我们去踢足球'
# 返回 True
str1.startswith('我们')
# 返回 False
str1.endswith('我们')
isdigit检查是否全由数字构成
str1 = input('请输入手机号码:')
# 如果是，返回True，否则返回False
# 不是全部由数字字符构成
if not str1.isdigit():
print('您输入的手机号码不正确，必须全部是数字')
count返回字符串对象包含了多少个指定参数
# 调用字符串的count 方法，这里返回2，
# 表示该字符串包含了两个 '我们'
word='我们今天不去上学，我们去踢足球'
print(word.count('我们'))
len()获取字符串长度
三、列表基础
1.列表（List）对象 经常被用来 存储 数据对象
列表想象为 一连串的储物格，每个储物格里面都可以存储 任何类型 的对象
存储整数、小数、字符串、函数、另一个列表对象等
# 每个对象之间用逗号隔开
a = [1, 2, 3.14, 'hello', [7,8,9]]
2.列表支持索引、切片
列表也是有sequnce特性的
索引
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
切片
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0:3] # 结果是 [1, 2, 3.14]
a[:3] # 结果也是 [1, 2, 3.14]
a[3:5] # 结果是 ['hello', [7,8,9] ]
a[3:] # 结果也是 ['hello', [7,8,9] ]
a[-1][:2] # 结果是 [7,8] 为什么？ 自己想一想
print(a)
# 结果还是 [1, 2, 3.14, 'hello', [7,8,9] ]
# 上面对a的切片操作是产生新的对象，并不会改变a指
3.改变列表内容
列表对象有个特点，它的内容是可以变化的
# 改变列表的内容
a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)
a[-1][-1] = '你好'
print(a)
# 执行结果
[1, 2, 3.14, 'hello', [7, 8, '你好']
列表的元素也可以填写变量
var = [7, 8, '你好']
a = [1, 2, 3.14, 'hello', var]
print(a)
# 执行结果
[1, 2, 3.14, 'hello', [7, 8, '你好']]
列表的元素还可以填写表达式
var = 100
a = [1, 2, var*3 + 20, 'hello', [7, 8, '你好']]
print(a)
# 执行结果
[1, 2, 320, 'hello', [7, 8, '你好']]
列表的元素替换
list1 = [0, 1, 2, 3, 4, 5]
# 方法一
list1[1] = 'a'
list1[2] = 'b'
list1[3] = 'c'
# 方法二，切片赋值；
list1[1:4] = ['a','b','c']
# 支持 替换的元素 比 被替换的元素 多
list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c','e','f','g','h']
# 结果为
[0, ‘a’, ‘b’, ‘c’, ‘e’, ‘f’, ‘g’, ‘h’, 4, 5]
合并两个列表
a = [1,2,3]
# 等价于 a=a+[4,5,6]
a += [4,5,6]
print(a)
# 执行结果
[1, 2, 3, 4, 5, 6]
4.列表生成式
# 生成1-10列表
list(range(1,11))
# 平方列表
[x * x for x in range(1,11)]
>>> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 平方列表只输出偶数的
[x * x for x in range(1,11) if x % 2 = 0]
>>> [4, 16, 36, 64, 100]
# 使用两次循环
[i + k for i in "ABC" for k in "XYZ"]
>>> ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
5.生成器
四、列表的方法
1.append改变列表的内容，在后面添加一个元素
在列表的内容后面，继续追加
a = [1, 2, 3.14, 'hello']
# append 之后，a就变成了 [1, 2, 3.14, 'hello', '你好']
a.append('你好')
print(a)
# 继续append ，a就变成了 [1, 2, 3.14, 'hello', '你好', [7,8]]
a.append([7,8])
print(a)
# append 方法的返回值是 None，而不是新的列表对象
b=a.append('嘻嘻')
print(
2.insert 指定位置插入一个元素
a = [1, 2, 3.14, 'python3.vip']
# 插入到索引0的位置，也是插到第1个元素的位置上
# a列表内容就变成了 ['你好', 1, 2, 3.14, 'python3.vip']
a.insert(0, '你好')
print(a)
# 插入到索引2的位置，也是插到第3个元素的位置上
# a列表内容就变成了 ['你好', 1, '黑羽', 2, 3.14, 'python3.vip']
a.insert(2, '黑羽')
print(a)
# insert方法的返回值也是 N
3.pop取出并删除一个元素
a = [1, 2, 3.14, 'python3.vip']
# 取出索引为3的元素，也就是第4个元素
# pop也经常用来删除某个元素
poped = a.pop(3)
# 取出后，a列表对象内容就变成了 [ 1, 2, 3.14]
print(a)
# 而取出的元素赋值给变量poped， poped的内容就是 'python3.vip'
print(pope
4.remove删除元素的值
remove从第1个元素开始，寻找 和参数对象 相等的元素，如果找到了，就删除
找到后，不会继续往后寻找其它相等的元素
remove 最多只会删除1个元素
var1 = ['a','b','c','a']
var1.remove('a')
print(var1)
# remove 方法的返回值也是 None
5.reverse将列表元素倒过来
# var1就变成了 [7, 6, 5, 4, 3, 2, 1]
var1 = [1,2,3,4,5,6,7]
var1.reverse()
print(var1)
# reverse 方法的返回值也是 None
6.index返回参数对象在列表中的位置，也就是索引
# idx的值为4,5这个元素在列表 var1中索引为4
var1 = [1,2,3,4,5,6,7]
idx = var1.index(5)
print(idx)
7.sort对列表进行排序
# after sort: ['Alex', 'Alex', 'Jerry', 'Michale', 'Tom']
students = ['Alex','Tom','Jerry','Michale','Alex']
students.sort()
print(f'after sort: {students}')
# after sort: [2, 3, 7, 8, 9]
numbers = [7,3,8,2,9]
numbers.sort()
print(f'after sort: {numbers}')
# sort方法的返回值是None
五、元组基础
元组(tuple)
1.元组（Tuple）也是一种sequence特性的类型，也可以存放任何类型的数据对象， 元组的内容是 **不能改变** 的
# 元组里面的每个对象，就称之为元组的一个元素
# 甚至还可以包含另一个列表或者元组作为元素
a = (1, 2, 3.14, 'hello', [7,8,9] )
# 元组中只有一个元素，必须要在后面加上逗号
a = (1, )
# 定义元组还可以去掉圆括号
a = 1, 2, 3.14, 'hello'
2.元组支持索引、切片
索引
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
切片
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0:3] # 结果是 (1, 2, 3.14)
a[:3] # 结果也是 (1, 2, 3.14)
a[3:5] # 结果是 ('hello', [7,8,9])
a[3:] # 结果也是 ('hello', [7,8,9])
a[-1][:2] # 结果是 [7,8] 为什么？ 自己想一
3.元组内容不可变，但是里面的列表内容可变
a = (1, 2, 3.14, 'hello', [7,8,9])
a[-1][0] = '你好'
print(a)
# 执行结果
(1, 2, 3.14, 'hello', ['你好', 8, 9])
4.判断元素是否在列表或元组中
# 检查 a 是否在var 中存在，存在返回True，否则返回False
a in var
# 检查 a 是否不在var 中，存在返回 False，否则返回 True
a not in var
# 具体例子
list1 = [1,2,3,4, 'hello']
tuple1 = (1,2,3,4, 'hello')
if 'hello' in list1:
print('hello 在列表中存在')
if 'boy' not in tuple1:
print('boy 在元组中不存
5.多个变量同时赋值
把 列表 或者 元组 中的元素直接赋值给变量
变量的个数一定要和 列表/元组 中元素的个数相等
x,y = (1,2) # x 的值为 1， y 的值为 2
print(x,y)
name, age = ['李逵', 33] # name 的值为 '李逵'， age 的值为 33
print(name,age
6.函数返回列表或者元组
# 放入列表中
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return [age,gender]
# 放入元组中
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return (age,gender)
#等价于
return age,gender
六、元组的方法
七、字典
字典是可变数据类型，但是字典的键是唯一，不可变
1.创建字典
1）使用 { } 创建字典
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
2）fromkeys() 方法创建字典
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
>>> {'语文': 60, '英语': 60, '数学': 60}
3） 通过 dict() 映射函数创建字典
# str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号
a = dict(str1=value1, str2=value2, str3=value3)
>>> {'str1': 1, 'str2': 2, 'str3': 3}
# 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值
demo = [('two',2), ('one',1), ('three',3)]
demo = [['two',2], ['one',1], ['three',3]]
demo = (('two',2), ('one',1), ('three',3))
demo = (['two',2], ['one',1], ['three',3])
a = dict(demo)
>>> {'two': 2, 'one': 1, 'three': 3}
# 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典
# -还可以是字符串或元组
keys = ['one', 'two', 'three']
# -还可以是字符串或元组
values = [1, 2, 3]
a = dict( zip(keys, values) )
>>> {'one': 1, 'two': 2, 'three': 3}
-不传入任何值
a = dict()
b ={}
2.访问字典
字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；
字典的值可以是 Python 支持的任意数据类型
1）Python 访问字典键值：
直接访问：
# 键必须存在，否则报错
dictname[key]
get方式：
# 当键存在时
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
# 当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '该键不存在') )
2）键值对
keys() 方法用于返回字典中的所有键（keys）
values() 方法用于返回字典中所有键对应的值（value）
items() 用于返回字典中所有的键值对items()
scores = {'数学': 95, '语文': 89, '英语': 90}
print(scores.keys())
print(scores.values())
print(scores.items())
# 返回的数据类型是dict_keys，<class 'dict_keys'> ；而不是元祖加列表
>>> dict_keys(['数学', '语文', '英语'])
>>> dict_values([95, 89, 90])
>>> dict_items([('数学', 95), ('语文', 89), ('英语', 90)])
3）使解决items() 的值
方法1：list()
# 使用 list() 函数，将它们返回的数据转换成列表
a = {'数学': 95, '语文': 89, '英语': 90}
b = list(a.keys())
print(b)
3.删除字典
a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del a
print(a)
4.操作字典
1）添加键值对
a = {'数学':95}
print(a)
#添加新键值对
a['语文'] = 89
print(a)
>>> {'数学': 95}
>>> {'数学': 95, '语文': 89}
2）修改键值对
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）
# 如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
a['语文'] = 100
print(a)
>>> {'数学': 95, '语文': 89, '英语': 90}
>>> {'数学': 95, '语文': 100, '英语': 90}
3）删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
4）判断字典中是否存在指定键值对
判断字典是否包含指定键值对的键，使用 in 或 not in
a = {'数学': 95, '语文': 89, '英语': 90}
# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True
八、字典的方法
copy() 方法
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)
>>> {'one': 1, 'two': 2, 'three': [1, 2, 3]}
九、集合
集合set中每个元素都是独一无二的
# 集合和字典很容易混淆，都是用一对花括号定义
# 当花括号没有键值对时，很可能就是集合
names = {"alice","tom","ben"}
# set函数
set3 = set((1,2,3,4,5))
>>> set3: {1, 2, 3, 4, 5}
同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型
浙公网安备 33010602011771号