python基本数据类型

字符串类型

字符串定义：

用来记录事物状态的性质：
比如：名字
name = 'Tom'

字符串特性：

不可变！
字符串：可以通过索引取子字符，也是字符串。
字符串无论符号、数字还是文字，都可以使用内置方法，字符串文字不会发生变化，类型依然属于字符串

1、需要掌握的功能

1.1、strip,lstrip,rstrip

str.strip() 括号中可以没有参数，默认清除空格，如果有参数，则清除参数值(参数不带空格，不清除空格)

msg = " ****helle**** "
print(msg.strip()) #去除空格
print(msg.lstrip()) #去除左边空格
print(msg.rstrip()) #去除有点空格
print(msg.strip(" *")) #去除空格和符号
"""
****helle****
****helle**** 
 ****helle****
helle
"""

1.2、lower ,upper

msg = "Hello"
print(msg.upper())#全部变成大写
print(msg.lower())#全部变成小写
"""
HELLO
hello
"""

1.3、startswith,endswith

msg = "nihaoa"
print(msg.startswith("ni")) #判断开头是否为ni
print(msg.endswith("a")) # 判断结尾是否为a
"""
True
True
"""

1.4、format

print("my name is %s age is %s"%("engo",18)) #位置固定
# my name is engo age is 18

print("my name is {x} my age is {y}".format(x="egon",y=18)) #可以赋值
#ma name is egon my age is 18

print("my name is {} my age is {}".format("egon",18,20))#不赋值则顺序填充,多一个值不报错，会根据有几个字符串格式化占位符，然后使用几个format后面的值，顺序赋值
# my name is egon my age is 18

print("my name is {0} my age is {1} 今年{1}".format("egon",18)) #花括号中填写数字取值为format中的索引，此方法format参数少于占位符也不会报错，按照索引取值可以重复取到值
# my name is egon my age is 18 今年18

x = 111
y = 222
print(f"my name is {x} my name is {y}") # f 的字符格式化，提前定义变量
# my name is 111 my name is 222

1.5、split（默认左到右切片）,rsplit（右切片）

找不到切片参数不会报错，输出原本字符串

msg = "x,y,z,b"

print(msg.split())#split无参数，按照空格切片，没有空格则不会切片
# ['x,y,z,b']

print(msg.split(",")) #有参数按照所给参数的符号切片
# ['x', 'y', 'z', 'b']

print(msg.split(",",1)) #左到右切一次
# ['x', 'y,z,b']

print(msg.rsplit(",",1)) #右到左切一次
# ['x,y,z', 'b']

1.6、join （可以拼接字符串，列表，元组）

join 拼接字符，需要赋值给全新的一个变量名
join 拼接列表，全为字符串，存在数字报错
join 也可以连接元组，全为字符串，存在数字报错

#  拼接输出结果为字符串类型

print(":".join(["aaa", "bbb", "ccc"])) # 根据句点符前面的""中字符拼接字符串
# aaa:bbb:ccc                 返回类型：字符串

name = ("aaa","bbb","123")
print("-".join(name))
# aaa-bbb-123

name ={"nihao":"wohao","aaa":"ccc"}
print("-".join(name)) #字典拼接为默认键的拼接
# nihao-aaa

name1= {'xiaoming':"18",'xiaohua':"20"}
print('+'.join(name1.values())) #拼接为键后的值 1820  拼接整型会报错

1.7、replace（字符串切换，不改变原字符）

会受到空格的影响，字符中间有空格，则判定不符合切换条件

msg = " egon is hhh egon xx egon"

print(msg.replace("egon","EGON")) # 默认把前面值全部改成后面的值
# EGON is hhh EGON xx EGON

print(msg.replace("egon","EGON",1)) # 后面带数字，修改具体数量参数
# EGON is hhh egon xx egon

1.8、isdigit：判断字符串是否数字组成

isdecimal() :判断字符串是否数字组成 （建议）
    
msg = "123"
print(msg.isdigit()) #判断字符串是否数字组成    True

number = "①"
print(number.isdigit())   #	True
print(number.isdecimal()) #	False

2、需要了解的功能

2.1、find(找字符,返回索引值) ，rfind（从右找字符,返回索引值） , index （找不到报错）, rindex , count（统计字符串的出现次数）

msg = "hello egon xxx egon yyy egon zzz"
print(msg.find("egon",0,7)) # 查找值在哪个位置 找不到返回 -1 ，后可跟查找范围
# -1

print(msg.find("egon",0,10))
# 6

print(msg.find("egon")) #不规定查找范围，全部查询
# 6

print(msg.rfind("egon")) #从右开始查找
# 24

print(msg.index("egon")) #查找，找不到报错
# 6

print(msg.rindex("egon")) #从右开始查找，查不到报错
# 24


print(msg.count('x')) # 统计字符串的出现次数 
# 3

2.2、center(居中),ljust（左对齐）.rjust（右对齐）,zfill（指定范围，用0填充)

print("nihao".cenetr(50)) # 50范围内剧中 
#       nihao        

print("nihao".center(9,"*"))  
#  **nihao**  

print("nihao".ljust(50)) # 50范围左对齐 ，填充空格

print('nihao'.ljust(50,"*")) #50范围字符串左对齐，填充 * 在右

print("nihao".rjust(50)) # 50范围字符串右对齐 ，填充 * 在左

print("nihao".rjust(50,"*"))# 50范围右对齐，填充"*"

print("nihao".zfill(10)) # 50范围左边填充0  
# 	0000000000nihao 类似rjust

3.3、captalize(单词首字母变大写，其他前部改成小写),swapcase（小写变大写，大写变小写）,title（每个单词首字母大写，其余小写）

msg = "nihao shijie"

print(msg.capitalize()) #只有第一个字母变成大写 Nihao shijie

msg1 = "Ni Hao" # 两极反转，大小写互换

print(msg.swapcase()) #nI hAO

msg2 = "ni hao"

print(msg2.title()) # Ni Hao

3.4、is 数字系列

isdigit() #变量值是字节串或者字符串类型并且包含的阿拉伯数字，结果才为真

isdecimal()#变量值是字符串类型并且包含的阿拉伯数字，结果才为真

isnumeric() #阿拉伯数字，中文数字，罗马数字，结果都为真

number1 = b"4"
number2 = "4"
number3 = "四"
number4 = "Ⅳ" 

print(number1.isdigit()) #True
print(number2.isdigit()) #True
print(number3.isdigit()) #False
print(number4.isdigit()) #False

print(number2.isdecimal()) #True
print(number3.isdecimal()) #False
print(number4.isdecimal()) #False

print(number2.isnumeric()) #True
print(number3.isnumeric()) #True
print(number4.isnumeric()) #True

3.5、 is其他

isalnum（）#判断字符串字母数字组成

msg = "nihao123"
print(msg.isalnum) # True 带空格或者其他字符都会报错

isalpha（）#判断字符串字母组成

msg = "Nihao" 
print(msg.isalpha()) # True 带空格会报错

islower（）#判断是否全部小写组成，带空格或者字符也为真

msg = 'a bcd'
print(msg.islower()) # True

isupper（）#判断是否全部大写组成，带空格或者字符也为真

msg = 'ABC D'
print(msg.isupper()) # True

字符串总结：

存一个值，有序，不可变类型

列表类型

1、列表用途：

按位置存放多个值

2、定义：

在[]内用逗号分割开多个任意类型的元素，所有可以被for循环遍历的类型，都可以传给list然后转换成列表

3、常用操作+内置方法

常用：

3.1、按照索引取值，赋值（正向索取+反向索取）：即可存也可取

注意：列表可以给存在的索引赋值，不可以给不存在的索引赋值

li = [1, 3, 5, 7, 8, 9]
print(li[0]) #输出列表索引为0的值

li[0]=0     #给列表0索引位置赋值0
print(li)  # [0, 3, 5, 7, 8, 9]

li[6]=10
print(li)  #赋值超过索引，报错，列表分配索引超出范围

3.2、切片（拷贝行为）

li = [1,2,3,4,5]
print(li[:])  #[1, 2, 3, 4, 5]

print(li.copy()) #[1, 2, 3, 4, 5]也是拷贝

3.3、长度

li = [111,2,33,5]
print(len(li)) # 输出列表长度
# 4

3.4、成员运算

li = [1,2,3,5,4,8,6]
name = int(input("输入账户密码："))

if name in li:
    print(name)
else:
    print("错误")
    
# 判定输入的值是否在列表

3.5、追加：

3.5.1、append，直接加到末尾。

li = [1, 3, 5, 7, 8, 9]

li.append("nihao") #在末尾追加"nihao"

print(li) # [1, 3, 5, 7, 8, 9, 'nihao']

3.5.2、insert（1，666）按照索引加

li = [1, 3, 5, 7, 8, 9]

li.insert(0,"ha") #在0索引位置添加"ha'

print(li) #['ha', 1, 3, 5, 7, 8, 9]

6，删除

3.6.1、单纯的删除：没有返回值

del list[0] #删除索引为0的值，不能赋值，赋值会报错 ，删除不存在索引也会报错

li = [1, 3, 5, 7, 8, 9]

del li[0] #删除列表中索引为0的值

print(li) # [3,5,7,8,9]

3.6.2、list.remove( )删除参数内的值，不存在则报错

li = [1, 3, 5, 7, 8, 9, 3]

li.remove(3) #删除列表中的3,只删除 一次 

print(li) #[1, 5, 7, 8, 9, 3]

3.6.3、取走：有返回值

list.pop()不指定值，默认参数为-1删除末尾，有返回值,删除不存在的索引也会报错

li = [1, 3, 5, 7, 8, 9,3]
number = li.pop() #删除最后的值
print(number) # 3 

li.pop(0) # 删除索引为0的值,删除不存在的索引也会报错
print(li) # [3,5,7,8,9]

li1 =["nihao",'wobuhao',1,'2']
print(li1.pop(1)) #拿走列表中索引1的值
print(li1) #['nihao', 1, '2']

7，循环

li = [1,2,3,4]
for i in li:
    print(i)
# 1 
# 2 
# 3 
# 4

8 .其他

3.8.1、count() :统计次数

li = [1,2,3,1,6,4,5]
print(li.count(1)) #2

3.8.2、list.reverse() : 列表倒着打印

li = [1,2,3,1,6,4,5]
li.reverse()
print(li) #[5, 4, 6, 1, 3, 2, 1]

3.8.3、list.clear() 清空列表

li = [1,2,3,1,6,4,5]
li.clear()
print(li) #[]

3.8.4、list.extend([]) 插入列表\元组中的每个元素

li = [1,2,3]
li.extend([4,5])
print(li) # [1,2,3,4,5]

li.extend((6,7))
print(li) # [1,2,3,4,5,6,7]

3.8.4、list.index(0 ，0，2) 查找值，后可规定范围，查不到报错

li = [1,3,4,5]
l = li.index(3)
print(l) 
# 1

li = [1,3,4,5,6,7]
l = li.index(5,0,4)
print(l)
# 3

3.8.5、list.sort() 排序，只有列表之间可以进行比较才可以排序

li = [1,8,2,3,5]
li.sort()
print(li)
# [1, 2, 3, 5, 8]

li = ['你','他','我','她']
li.sort()
print(li)
# ['他', '你', '她', '我']

注意：
	列表同时存在整型和字符串时用sort会报错，整型和字符串不能进行比较

3.8.6、list.sort(reverse = True) 反过来排序

li = [1,8,2,3,5]
li.sort(reverse=True)
print(li)
# [8, 5, 3, 2, 1]

列表总结：

存放多个值，有序，可变

元组类型 tuple

1、用途：

按照位置存放多个值，可读不可改

2、定义：

在（）内用逗号分隔开多个任意类型的元素

定义的元组中只有一个值，需要加逗号

tuple数据类型转换：任意能被for循环遍历的类型，都可以交给tuple转成元组
a = (1) 
print(a) #输出1为整型   1
b = (2,)
print(b) # 输出2为元组 （2，）

3、常用操作+内置方法

优先掌握：

3.1、按索引取值（正向取+反向取）：

tup = (1,2,3,4,5,6)
print(tup[0])  #1
print(tup[1])  #2
print(tup[5])  #6
print(tup[-1]) #6

3.2、切片

tup = (1,3,4,5,7)
print(tup[1:3]) #(3,4)
print(tup[::-1])#(7,5,4,3,1)

3，长度

tup = (1,3,4,5,6)
print(len(tup)) #5

4，成员运算

tup = (1,3,4,5,"nihao")
if "nihao" not in tup:
    print("不在成员中")
else:
    print("内部成员")
# 输出结果：内部成员

5，循环

tup = (22,44,11,55)
for i in tup:
    print(i)
# 22
# 44
# 11
# 55

元组总结：

存放多个值，有序，不可变

字典类型

1.用途:

存放多个由键值组成的键值对，可读，值可改

2，定义：

用{}内用逗号分开多个元素，每个元素都是以key：value的格式，其中value可以是任意类型，而key必须是不可变类型，通常是str类型，而且key不能重复

不可哈希就是可变，可哈希就是不可变

3、dict数据类型转换

字典只有转换成字符串的时候，才可以全部显示键值对。

如果字典转换成元组或者列表或者集合，都是默认生成的为键组成的元组或者列表或者集合。

通过dic.value() 获得值组成的元组或者列表或者集合，

也可以通过dic.items()获得键值而组成的元组或者列表或者集合。

dic = {'name': 'Zara', 'age': 7, 'class': 'First'}

print(str(dic)) # 转换字符，键值对全部转换 {'name': 'Zara', 'age': 7, 'class': 'First'}

print(list(dic)) # 转换列表，默认列表生成键 ['name', 'age', 'class']

print(list(dic.values())) # 获取值生成列表 ['Zara', 7, 'First'] 

print(list(dic.items()))  # 获取键值对生成列表，为元组组成列表，即列表套元组 [('name', 'Zara'), ('age', 7), ('class', 'First')]

4、常用操作+内置方法

优先掌握操作：

4.1、按照key存取值：可存可取

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
print(dic['name'])  # xiaofang
print(dic['age'])   # 18
print(dic['hobby']) # Basketable

dic['name'] = "xiaoming"
print(dic) # {'name': 'xiaoming', 'age': 18, 'hobby': 'Basketball'}

dic['love'] = 'liu'
print(dic) # {'name': 'xiaoming', 'age': 18, 'hobby': 'Basketball','love':"liu"}

4.2、长度

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
print(len(dic)) # 3

4.3、成员运算

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
if 'name' in dic:
    print("内部成员") # 内部成员
    
if "xiaofang" in dic['name']:
    print("内部成员") # 内部成员
    
if "xiaoming" in dic.values():
    print("内部成员") # 内部成员

4.4、删除

4.4.1、单纯删除：del dic[" "]

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
del dic['name']
print(dic) # {'age': 18, 'hobby': 'Basketball'}

4.4.2、取走：

dic.pop ( " " )括号内是要删除的key值，返回值为key对应的value

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
d = dic.pop("name")
print(d,dic) #xiaofang {'age': 18,'hobby': "Basketball"}

4.4.3、dic.popitem() 随机删除，删除后的值，返回key和value组成的元组

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}

d = dic.popitem()
print(d,dic) 
# ('hobby', 'Basketball') {'name': 'xiaofang', 'age': 18}

4.5、循环

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
for i in dic: #等同于 for i in dic.keys():
    print(i) # 默认输出所有键
#    name
#    age
#    hobby

for i in dic.values():
    print(i) #输出所有键对应的值
# xiaofang
# 18
# Basketball

for i in dic.items(): #输出键值对从而形成的元组
    print(i) 
#    ('name', 'xiaofang')
#    ('age', 18)
#    ('hobby', 'Basketball')

for x,y in dic.items(): #输出的元组分别赋值给x，y，解压赋值操作
    print(x,y)
#    name xiaofang
#    age 18
#    hobby Basketball
    

4.6get（）如果key不存在，就默认返回None，也可以设置返回其他值

dic.get("name")

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
name = dic.get("name")
print(name) # xiaofang

num = dic.get('oho')
print(num) # None

nba = dic.get('nba','不存在')
print(num) # 不存在

需要掌握的操作：

4.7、dic.update({}) :更新，没有加入，有就更新，字典内可以有几个键值对

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
dic.update({"name":"xiaoming"})

print(dic)
# {'name': 'xiaoming', 'age': 18, 'hobby': 'Basketball'}

dic.update({'love':'liu'})

print(dic)
# {'name': 'xiaoming', 'age': 18, 'hobby': 'Basketball', 'love': 'liu'}

案例2
dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
dic.update({'name':'小明','love':'liu'})
print(dic)
# {'name': '小明', 'age': 18, 'hobby': 'Basketball', 'love': 'liu'}

4.8、{}.formkeys(["1","2"], none) :根据前面列表快速生成key值

dic = {}.fromkeys((1,3),None)
print(dic) # {1: None, 3: None}
dic1 = {}.fromkeys([1,2],None)
print(dic1) # {1: None, 2: None}

4.9、dic.setdefault("name","xxx"):判断字典里面是否有个name这个key，有就不更改，没有就更新字典中的key，value，返回值为：key对应的value

dic = {
    'name': "xiaofang",
    'age': 18,
    'hobby': "Basketball"
}
c = dic.setdefault('name','xiaoming')
print(dic,c)

# {'name': 'xiaofang', 'age': 18, 'hobby': 'Basketball'} xiaofang
d = dic.setdefault('love','liu')

print(dic,d)
#  {'name': 'xiaofang', 'age': 18, 'hobby': 'Basketball', 'love': 'liu'} liu

字典总结：

存放多个值，无序，字典本身可变，字典的key不可变