python基础数据类型

一.字符串（string）

1.1字符串的赋值

1.1.1直接赋值

使用’’,"",’’’ ‘’’(单、双、三引号)和“=”赋值符号，进行字符串赋值
示例：
一对引号字符串（单引号，双引号）
name1 = ‘Tom’
name2 = “Rose”
三引号字符串(三个单引号和三对双引号)
name1 = ‘’‘Tom’’’
name2 = “”“Rose”""
a = ‘’’
i am Tom,
nice to meet you
‘’’
b = “”"
i am Rose，
nice to meet you,too
“”"
注意：三引号形式的字符串支持换行

1.1.2通过input（）方法

1.1.2 字符串输入
在python中，使用input()接收用户输入。
代码
username = input(‘请输入用户名：’)
print(type(username))
print(f"您输入的名字是{username}")
password = input(‘请输入密码:’)
print(f’您输入的密码是{password}’)

1.2字符串拼接

每一个字符串，可以代表一段话、或者一个词组。例如：
agreement = ‘http://’
ip = ‘121.42.15.146:9090’
url = ‘/mtx/’
如果想让这三个字符串，拼接成一个完整的地址。我能怎么做？
这里就要用到字符串拼接
方式1：使用加号。要求：各个变量或者元素必须是字符串类型
var1 = ‘字符串’
var2 = str(1)
print(var1 + var2)
print(type(var1 + var2))
经典误区：
print打印时使用,（逗号）不是字符串合并
print（‘你’,‘好’）
方式2：
使用f’’ *需要python解释器是3.6之后的版本
var = ‘字符串’
name = f’我是{字符串}’
print(type(name))

1.3字符串操作

索引是从0开始的整数
正着数 从0开始
逆着数 从-1
数据类型分为可变和不可变数据类型
不可变类型（数字，字符串，元组）：不支持原址（内存地址）修改
举个例子：
*id()是用来查看内存地址的方法
v = ‘我是一个字符串’
print (id(v))
v = ‘我变了’
print (id(v))

1.3.1下标

‘下标’ 也就是’索引’,就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。
同理，下标的作用就是通过下标快速找到对应的数据
需求：字符串 name = ‘testfan’ ，取到不同下标对应的数据
#取到不同下标对应的数据
name = ‘testfan’
print(name[0])
print(name[1])
print(name[2])
#下标也可以写负数
print(name[-1])
print(name[-2])
*下标从0开始

1.3.2切片

切片是指对操作的对象截取其中一部分的操作，字符串，列表，元组都支持切片
语法
字符串[开始位置下标:结束位置下标:步长]
注意：
选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，
如果不写步长默认是1.
步长是控制方向的，正数从左往右取，负数是从右到左取我们以字符串为例讲解
小结：
1.[:]提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
2.[start:]从start提取到结尾
3.[:end]从开头提取到end-1
4.[start:end]从start提取到end-1
5.startstep]从start提取到end-1，每step个字符提取一个
6.[::-1]逆序

1.3.3遍历字符串

python中的for循环，可以自动遍历字符串序列的每一个元素
name = ‘testfan’
print(name[2:5:1]) # 下标2到5，步长是1
print(name[2:5]) # 默认步长是1
print(name[:5]) # 不写起始，则认为是从头开始
print(name[2:5:2]) # 步长为2就后面元素的索引-前面的索引=步长
print(name[::]) # testfan
print(name[:]) # testfan
print(name[-5:-1]) # 倒叙截取，从-5个字符(重点)
print(name[-5:])
print(name[:-1])
print(name[::-1])
print(name[-3:])
print(name[2:-3])
for i in var:
if i==‘一’:
print(‘特殊处理’)
print(i)

1.3.4字符串方法

字符串的常用操作方法有查找，修改和判断三大类.
我们在这先提出最必须背下来的几个方法：find()、replace()、split()
*思考一下，想要使用这里的方法，例如find()，有什么要求？
find():检测某个字符串是否在某个字符串中，如果在，就返回子串开始位置的下标，否则，返回-1
1.语法
注意：开始和结束位置下标可以省略，表示在整个字符串序列当中查找
2.快速体验
replace()：替换
1.语法
注意：替换次数如果超出子串出现的次数，则替换次数为该子串出现的次数
2.快速体验
注意：数据按照是否能直接修改分为可变类型和 不可变类型两种。字符串类型的数据修改的
时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。
split(): 按照指定字符分隔字符串
1.语法
注意：num表示的是分隔字符出现的次数，即将来返回数据个数为num+1
字符串序列.find(子串,开始位置下标，结束位置下标)
str= ‘hello world and test and name’ #12
print(str.find(‘and’)) # 返回的是字串在字符串当中的开始位置的索引
print(str.find(‘and’,15,-1)) #24
print(str.find(‘ands’)) # -1
字符串序列.replace(旧子串，新子串，替换次数)
str = ‘hello world and test and name’
#1.replace
#结果：hello world and test and name
print(str) # 字符串是不可变类型，所以不会改变原来数据的结构
#结果：hello world and test and python
print(str.replace(‘name’,‘python’))
#结果:hello world 2 test 2 name
print(str.replace(‘and’,‘2’)) # 默认是更改所有的
#结果：hello world 2 test and name
print(str.replace(‘and’,‘2’,1))
#结果：hello world 2 test 2 name
print(str.replace(‘and’,‘2’,3))
字符串序列.split(分割字符，num)
2.快速体验
#结果:[‘hello’, ‘world’, ‘and’, ‘test’, ‘and’, ‘name’]
print(str.split(’ ‘)) # 经过split()分隔之后就是一个列表
#结果：[‘hello’, ‘world’, ‘and test and name’]
print(str.split(’ ', 2))
#结果: ['hello world ‘, ’ test ‘, ’ name’]
print(str.split(‘and’)) # 如果分隔符是字符串序列的一个子串，那么就会丢失
注意： 如果分割字符是原有字符串中的子串，分割后则丢失该子串
capitalize(): 将字符串第一个字符串转换成大写
str = ‘hello world and test and name’
#结果是Hello world and test and name
print(str.capitalize())
注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写
title() ：将字符串每个单词首字母转换成大写
str = ‘hello world and test and name’
#结果：Hello World And Test And Name
print(str.title())
lower(): 将字符串中大写转小写
str1=str.title()
print(str1)
print(str.lower())
upper():将字符串中小写转大写
str = ‘hello world and test and name’
#结果：HELLO WORLD AND TEST AND NAME
print(str.upper())
lstrip():删除字符串左侧空白字符
str = ’ hello world and test and name’
print(str)
print(str.lstrip())
执行结果：
rstirp():删除字符串右侧空白字符
strip():删除字符串两侧空白字符
1.3.4.3 判断(了解)
判断里面的内容只知道如何去用，见到方法知道什么意思，或者你想用哪一个方法你知道对应的是哪一
个方法就可以。
可以通过字符串.然后查看里面的api，然后进行选择。
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False
startswith():检查字符串是否是以指定子串开头，是则返回True，否则返回False。如果设置开始和
结束位置下标，则在指定范围内检查
1.语法
字符串序列.startswith(子串，开始位置下标，结束位置下标)
2.快速体验
str1 = ‘helloworld11111’
print(str1.startswith(‘hell’)) # True
print(str1.startswith(‘hello’,5,-1)) #False
endswith(): 检查字符串是否是以指定子串结尾，是则返回True，否则返回False。
如果设置开始和结束位置下标，则在指定范围内检查
1.语法
字符串序列.endswith(子串，开始位置下标，结束位置下标)
2.快速体验
str1 = ‘helloworld11111’
print(str1.endswith(‘11’)) # True
print(str1.endswith(‘11’,0,7)) # False
isalpha():如果字符串至少有一个字符并且所有的字符都是字母则返回True，否则返回False
isdigit():如果字符串只包含数字则返回True，否则返回False
isalnum():如果字符串中至少有一个字符并且所有的字符是字母或者数字则返回True,否则返回False
isspace(): 如果字符串中只包含空白，则返回True，否则返回False
面试题
字符串反转

二.列表

列表是用来存储多组数据的

1. 列表的基本规则

1.列表使用[]来表示
2.初始化列表：
list = []
3.列表可以一次性存储多个数据
4.列表中的每一项，都能是不同的数据类型。（包括列表）
str1=‘hello’
str2=‘hello111’
str3=’’
print(str1.isalpha()) # True
print(str2.isalpha()) # False
print(str3.isalpha()) # False
str1 = ‘1234’
str2 = ‘hello 777’
print(str1.isdigit()) # True
print(str2.isdigit()) # False
str1 =‘aaa123’
str2 =‘aaa-’
print(str1.isalnum()) # True
print(str2.isalnum()) # False
str1 = ’ ’
str2 = ’ hello’
print(str1.isspace()) # True
print(str2.isspace()) # False
[数据1，数据2，数据3，…]
范例：
#列表的元素多种多样（指类型）
test_list = [1,‘a’,[1,2],{“name”:“刘备”},{2,3},(1,2,“李四”)]
#列表的输出
names_list = [‘刘备’,‘曹操’,‘孙权’]
print(names_list[0])
print(names_list[1])
print(names_list[2])
print(names_list)
列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有:增删改查

2.列表的常用操作

2.1查找

2.1.1下标

name_list=[‘tom’,‘lily’,‘rose’]
print(name_list[0]) # tom
print(name_list[1]) #lily
print(name_list[2]) # rose

2.1.2函数(方法)

index(): 返回指定数据所在位置的下标
1.语法
列表序列.index(数据，开始位置的下标，结束位置的下标)
2.快速体验
name_list = [‘tom’,‘lily’,‘rose’]
print(name_list.index(‘tom’)) # 0
注意：如果查找的数据不存在则报错
count()：统计指定数据在当前列表中出现的次数
name_list=[‘tom’,‘lily’,‘rose’]
print(name_list.count(‘tom’)) # 1
len()：可以获取列表的长度，即列表中数据的个数
name_list=[‘tom’,‘lily’,‘rose’]
print(len(name_list)) # 3

2.1.3 判断是否存在

in:判断指定的数据在某个列表序列，如果在返回True,否则返回False
name_list=[‘tom’,‘lily’,‘rose’]
print(‘lily’in name_list) #True
print(‘yao’ in name_list) #False
not in :判断指定的数据不在某个列表序列，如果不在返回True，否则返回False
name_list=[‘tom’,‘lily’,‘rose’]
print(‘tom’ not in name_list) # False
print(‘yaoyao’ not in name_list) #True
体验案例
需求：查找用户输入的名字是否存在
name_list=[‘tom’,‘lily’,‘rose’]
name = input(‘请输入你要搜索的名字:’)
if name in name_list:
print(f’您搜索的{name}存在’)
else:
print(f’您搜索的{name}不存在’)

2.2增加

作用：增加指定数据到列表中
append()：列表尾部追加数据
1.语法
列表序列.append(数据)
2.体验
name=[‘tom’,‘lily’,‘rose’]
name.append(‘xiaoming’)
print(name)
执行结果：
列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数
据
3.注意点
如果append()追加的数据是一个序列，则追加整个序列到列表,整体新增一个元素。
name_list = [‘tom’,‘lily’,‘rose’]
name_list.append([‘xiaoming’,‘xiaohong’])
#结果：[‘tom’, ‘lily’, ‘rose’, [‘xiaoming’, ‘xiaohong’]]
print(name_list)
insert(): 指定位置新增数据
1.语法
列表序列.insert(位置下标，数据)
2.快速体验
name_list = [‘tom’,‘lily’,‘rose’]
name_list.insert(0,‘yao123’)
#结果：[‘yao123’, ‘tom’, ‘lily’, ‘rose’]
print(name_list)
extend(): 列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一加入列表中
1.语法
列表序列.extend(数据)
2.快速体验
2.1单个数据（可迭代的）
name_list = [‘tom’,‘lily’,‘rose’]
name_list.extend(‘abc’)
#结果：[‘tom’, ‘lily’, ‘rose’, ‘a’, ‘b’, ‘c’]
print(name_list)
2.2序列数据
name_list = [‘tom’,‘lily’,‘rose’]
name_list.extend([‘a’,‘b’,‘c’])
#结果：[‘tom’, ‘lily’, ‘rose’, ‘a’, ‘b’, ‘c’]
print(name_list)

2.3删除

del
1.语法
del 目标
2.快速体验
2.1删除列表
name_list = [‘tom’,‘lily’,‘rose’]
del name_list
#结果：NameError: name ‘name_list’ is not defined
print(name_list)
2.2删除指定数据
name_list = [‘tom’,‘lily’,‘rose’]
del name_list[0]
#[‘lily’, ‘rose’]
print(name_list)
remove()
pop()：删除指定下标的数据（默认为最后一个），并返回该数据
1.语法
列表.pop(index)
2.快速体验
name_list = [‘tom’,‘lily’,‘rose’]
del_name = name_list.pop(0) # 返回的是被删除的元素
#结果是tom
print(del_name)
#结果是[‘lily’, ‘rose’]
print(name_list)
#不加索引，默认删除最后一个元素
name_list.pop()
#结果是[‘lily’]
print(name_list)
clear():清空列表
name_list = [‘tom’,‘lily’,‘rose’]
name_list.clear() #清除列表里面的所有元素
#结果是[]
print(name_list)

2.4修改

修改指定下标数据
name_list = [‘tom’,‘lily’,‘rose’]
name_list[0]=‘yao123’
name_list[2]=“yao123”
#[‘yaoyao’, ‘lily’, ‘rose’]
print(name_list)
逆转:reverse()
name_list=[‘tom’,‘lily’,‘rose’]
name_list.reverse()
#[‘rose’, ‘lily’, ‘tom’]
print(name_list)
排序：sort()
1.语法
列表.sort(key=None,reverse=False)
注意：reverse表示排序规则，reverse=True 降序，reverse=False 升序（默认）
2.快速体验
name_list=[1,7,3,2,8]
name_list.sort()
#[1, 2, 3, 7, 8]
print(name_list)
列表去重，保证索引位置不变。

2.5 使用join关键字，范例：

分隔符.join(元组和列表) -----把列表和元组转换成字符串
#[]是列表
#var=[‘我是’,‘一个’,‘列表’]
#单纯连接
#print(type(var))
#var=’’.join(var)
#print(type(var))
#print(var)
另一种形式
#s = ‘2’
#s1 =‘o’
#v =s,s1
#print(’’.join(v))

3. 列表的循环遍历

需求：依次打印列表中的各个数据

3.1 while

代码
name_list=[‘tom’,‘lily’,‘rose’]
n=0
while n<len(name_list):
print(name_list[n])
n += 1
执行结果：

3.2 for

代码
name_list=[‘tom’,‘lily’,‘rose’]
for i in name_list:
print(i)

4. 列表嵌套

所谓列表嵌套指的是一个列表里面包含了其他的子列表
应用场景：要存储高三三个班级的学生名字，每个班级的学生名字为一个列表
name_list = [[‘xiaoming’,‘xiaohong’,‘xiaoli’],[‘tom’,‘lily’,‘rose’],[‘小李’,‘小
杨’,‘小张’]]
思考：如何查找到数据"小李"
print(name_list[2][0])

5. 列表推导式

列表推导式：使用一行代码简单快速的创建一个列表。
#生成一个列表
num_list = [value for value in range(1, 4)]
print(num_list)
#对列表中的数据进行过滤
data_list = [1, 9, 2, 10]
new_list = [value for value in data_list if value % 2 == 0]
print(new_list)
#字符串转列表，每个元素复制成两份
info_str = “abc”
new_str = [value * 2 for value in info_str]
print(new_str)

6. 面试题

面试题：l= [‘Hello’, ‘World’, 18, ‘Apple’, None],
对l列表进行操作，把每个字符串变成小写字母，数字和None保持原样，然后重新返回一个新列表

三.元组

1.元组的应用场景

思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改
num_list =[10,20,30]
num_list[0] = 100
一个元组可以存储多个数据，元组内的数据是不能修改的

2.定义元组

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。
#多个数据元组
t1 = (10,20,40)
#单个数据元组
t2 = (10,)
注意: 如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型就变成了元
组里面的那个唯一的数据的数据类型
a = (1)
print(type(a)) #<class ‘int’>
b = (‘你好’)
print(type(b)) # <class ‘str’>
c = (‘yaoyao’,)
print(type©) #<class ‘tuple’>

3.元组的常见操作

元组数据不支持修改，只支持查找，具体如下：
按照下标查找数据
tuple1 = (‘aa’,‘bb’,‘cc’,‘dd’)
print(tuple1[0]) # aa
len() 统计元组中数据的个数
tuple1 = (‘aa’,‘bb’,‘cc’,‘dd’)
print(len(tuple1)) # 4
注意：元组内的直接数据如果修改则立即报错
tuple1 =(‘aa’,‘bb’,‘cc’,‘dd’)
tuple1[0]=‘mm’ # TypeError: ‘tuple’ object does not support item assignment
但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要
tuple1 = (10,20,20,[‘lily’,‘lucy’],40)
tuple1[3][0]=‘tom’
#结果是(10, 20, 20, [‘tom’, ‘lucy’], 40)
print(tuple1)

四.字典

目标
字典的应用场景
创建字典的语法
字典常见的操作
字典的循环遍历

1. 字典的应用场景

存储键值对数据时使用，python里唯一具备映射关系的数据类型

2. 创建字典的语法

字典的特点
符号用大括号
里面的数据以键值对形式出现
各个键值对之间用逗号隔开
#有数据的字典
dict1 = {‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
#空字典
dict2 = {}### 经常
dict3 = dict()
注意：一般称冒号前面的为键（key），简称k，冒号后面的为值（value），简称v

3. 字典常见操作

3.1 增

写法：字典序列[key]=值
注意：如果key存在则修改这个key对应的值，如果key不存在则新增此键值对
dict1 ={‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
#结果是{‘name’: ‘lily’, ‘age’: 20, ‘gender’: ‘男’}
dict1[‘name’]=‘lily’
print(dict1)
dict1[‘id’]=‘001’
#结果是{‘name’: ‘lily’, ‘age’: 20, ‘gender’: ‘男’}
print(dict1)
字典为可变类型

3.2删

del()/del: 删除字典或删除字典中指定键值对
dict1 ={‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
del dict1[‘name’]
print(dict1) #{‘age’: 20, ‘gender’: ‘男’}
del(dict1[‘age’])
print(dict1) # {‘gender’: ‘男’}
del dict1
print(dict1) # 报错：字典没有被定义
clear() 清空字典
dict1 ={‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
dict1.clear()
print(dict1) # {}

3.3 改

写法：字典序列[key]=值
注意：如果key存在则修改，不存在则添加

3.4 查

3.4.1 key值查找
dict1 ={‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
print(dict1[‘name’]) #tom
print(dict1[‘id’]) #报错
注意：如果当前查找的key存在，则返回对应的值，否则会报错。
3.4.2 get()
语法
dict.get(key,默认值)
注意：如果当前不存在这个key，则会返回第二个参数自定义的默认值，如果没有第二个参数，则
返回默认的None
快速体验
dict1 ={‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
print(dict1.get(‘name’)) # tom
print(dict1.get(‘id’, ‘不存在’)) # 不存在

4. 字典的循环遍历

4.1 遍历字典的key

dict = {‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
for k in dict.keys():
print(k)
执行结果是

4.2遍历字典的value

dict = {‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
for v in dict.values():
print(v)
执行结果是

4.2遍历字典的元素

dict = {‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
for items in dict.iitems()
print(items)
执行结果是

4.3遍历字典的键值对

dict = {‘name’:‘tom’,‘age’:20,‘gender’:‘男’}
for k,v in dict.items():
print(k,v)
执行结果

4.4 面试题

对列表去重(使用字典特性实现)