1. 整型
是否可变类型： 不可变类型
# 作用：记录年龄、手机号
# 定义：
age = 18 # --> 内部操作 age = int(18)
# int('sada') # 报错
int(1.1)
# int('1.1') # int() 只能转纯数字的字符串，小数点都不行
a = 11111
print(id(a))
a = 122121
print(id(a))
# 2250375207952
# 2250375207632
# id变了，所以是不可变类型
可变类型和不可变类型
''
可变类型： 值改变的情况下，id不变，说明你改的是原值
不可变类型：值改变的情况下，id一定变
'''
2. 进制之间的转换
??进制转换为其他进制
1 # -------------- 十进制 --> 其他进制 -------------
2 # 》》》 十进制转二进制 《《《
3 print(bin(12)) # 0b1100 0b表示后面的数字是二进制数
4
5 # 》》》 十进制转八进制 《《《
6 print(oct(12)) # 0o14 0o表示后面的数字是八进制14 >>> 1*(8**1) + 4*(8**0)
7
8 # 》》》 十进制转十六进制 《《《
9 print(hex(12)) # 0xC 0x表示后面的数字是十六进制数
10
11 # 0b1100
12 # 0o14
13 # 0xc
其他进制转十进制
2 # 》》》二进制转十进制《《《
3 10 # 1*(2**1) + 0*(2**0) 2
4 print(int('1100', 2))
5 # 12
6
7 # 》》》八进制转十进制《《《
8 235 # 2*(8**2) + 3*(8**1) + 5*(8**0)
9 print(int('14', 8))
10 # 12
11
12 # 》》》十六进制转十进制 0-9 A-F《《《
13 217 # 2*(16**2) + 1*(16**1) + 7*(16**0)
14 print(int('c', 16))
15 # 12
2. 浮点型
作用： 薪资、身高、体重
# 是否可变类型：不可变类型
res = float('1.11')
print(type(res))
# <class 'float'>
print(id(res))
res = 1.2 # --> res = float(1.2)
print(id(res))
# 2955868840344
# 2955868840320
3. 字符串
用途：存放描述性信息
# 虽然它可以用索引取值，但其本质上只有一个值
# 有序（有序： 但凡有索引的数据都是有序的）
# 是否可变类型：不可变类型
# 定义方式： '内容', "内容", '''内容''', """内容"""
# 之所以提供这么多定义方式（引号）是因为引号可能会用到
s = 'hello world' # s = str('hello world')
s1 = str([1, 2, 3, 4]) # 等同于在其两边套上了引号
print(s1, type(s1))
# [1, 2, 3, 4] <class 'str'>
s1 = str({'name': 'jason', 'age': 18})
print(s1, type(s1))
# {'name': 'jason', 'age': 18} <class 'str'>
按索引取值
tring = 'hello world.'
print(string[0])
# h
# string[0] = 'H' # 直接报错，str 字符串类型只能按索引取值，不能通过索引改
切片操作
切片（顾头不顾尾，步长）：从一个大的字符串中截取一段新的小字符串
s = 'hello big baby~'
print(s[0: 10])
print(s[0: 10: 2])
# hello big
# hlobg
print(s[-1])
# -1 取最后一个字符
print(s[-2])
# -2 取倒数第二个字符
# 切片取值默认是从左往右的
print(s[5: 0: -1]) # 从5 开始 到0 （顾头不顾尾，顾5 不顾 0）
# olle
print(s[-1: -10])
print(s[-1: -10: -1])
#
# ~ybab gib
4. 内置函数
strip() 默认去除字符串左右两端的指定字符(默认为空，去除左右两端空格)
name = 'jason'
name2 = ' jason '
print(name == name2, name.strip() == name2.strip())
# False True
# 去除两端的指定字符
name = '$$$$egon$A$$$'
print(name.strip('$'))
# egon$A
# 去除多字符也可以
name = '$%@ jason*&^('
print(name.strip('$%@ &('))
# jason*&^
# lstrip() 去除字符串左侧指定字符
name = '$$jason##$$'
print(name.lstrip('$')) # left 左
# jason##$$
# rstrip() 去除字符串右侧指定字符
print(name.rstrip('$')) # right 右
# $$jason##
字符串切割
split 将字符串按照指定字符切割成列表，可指定切割次数
# split：针对按照某种分隔符组织的字符串，可以用split将其切分成 [列表] ，进而进行取值
# 切割顺序是从左往右的
data = 'jason|123|handsome'
name, age, description = data.split('|')
print(data.split('|'))
print(name, age, description)
# ['jason', '123', 'handsome']
# jason 123 handsome
data = 'jason|123|handsome'
print(data.split('o', 1)) # 通过参数指定切割次数
print(data.split('o'))
print(data.rsplit('o'))
# ['jas', 'n|123|handsome']
# ['jas', 'n|123|hands', 'me']
# ['jas', 'n|123|hands', 'me']
# 如果不指定，rsplit() 和 split() 是一样的
将字符串以指定字符(串)作为分隔拼接起来
join 将列表以指定字符串作为分隔拼接起来
data = 'jason|123|handsome'
res_list = data.split('|')
res_str = ' '.join(res_list)
print(res_str)
# jason 123 handsome
# l = [1, 'a', 'b']
# res = '|'.join(l) # ----》报错，不同类型不能相加（拼接）《----
# print(res)
迭代器对象循环遍历
在for 循环中遍历
data = 'jason|123|handsome beatiful'
for i in data:
print(i, end='--')
# j--a--s--o--n--|--1--2--3--|--h--a--n--d--s--o--m--e-- --b--e--a--t--i--f--u--l--
print()
转换字符串大小写(只影响字母)
lower upper 函数统一转换字符串的大小写
s = 'HAfaganGA'
print(s.lower())
print(s.upper())
print(s)
# hafaganga ————> 全转换成小写
# HAFAGANGA ————> 全转换成大写
# HAfaganGA ————> s 本身没有发生改变
# 调用方法并不改变字符串本身
# captallize swapcase titlle 大小写转换意义化
s = 'hElLo WoRLD10'
print(s.capitalize()) # 整个字符串首字母大写，其他都变小写（全大写文章转换成句子）
print(s.swapcase()) # 大小写交换
print(s.title()) # 单词之间首字母大写 （全大写单词转换成首字母大写的单词）
# Hello world10
# HeLlO wOrld10
# Hello World10
开头/结尾
startswith 判断字符串是否以...开头
# endswith 判断字符串是否以...结尾
s = 'jason dsb'
print(s.startswith('jas'))
print(s.endswith('sb'))
# True
# True
字符串格式化
format 字符串格式化 （python推荐使用format 做替换，做格式化输出）
# 三种玩法
# 1.按位置占位 --> 与 %s 原理一样
name = 'jason'
age = 18
str1 = 'my name is {} my age is {}'.format(name, age)
print(str1)
# my name is jason my age is 18
# 2.按索引占位 --> 支持一个变量多个位置调用
str1 = 'my name is {0} my age is {0}'.format("egon", 18)
print(str1)
# my name is egon my age is egon # {0} {0}都用的第一个参数
# 3.指名道姓（关键字传参）占位，同样支持一个（关键字）变量多个位置调用
name = 'jason'
age = 18
str1 = 'my name is {name} my age is {age} name = {name}'.format(name=name, age=age)
print(str1)
# my name is jason my age is 18 name = jason
将字符串的指定字符（串）替换成新的指定字符（串），可以指定次数
replace 替换指定字符（串）成新的指定字符（串），可指定次数
string = 'egon is dsb and egon is sb and egon has a BENZ'
res = string.replace('egon', 'kevin', 2)
print(res)
# kevin is dsb and kevin is sb and egon has a BENZ
# replace('要替换的旧字符串', '新的字符串', 替换个数)
字符串是否是数字
is 数字系列
# isnumeric() 只要是数字都识别，不能识别二进制
# isdecimal() 只能识别普通的阿拉伯数字 0123456789
# isdigit() 数字都能识别（包括二进制） --> 通常情况下使用它就能满足需求了
# 在python3中
num1 = b'4' # bytes
num2 = u'4' # unicode,python3中无需加u就是unicode
num3 = '壹' # 中文数字
num4 = 'Ⅳ' # 罗马数字
# ''.isnumeric(): unicode,中文数字，罗马数字
# print(num1.isnumeric()) # 直接就会报错，num1 根本就没有isnumeric 这个方法
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
# True
# True
# True
# ''.isdecimal(): unicode
# print(num1.isdecimal()) # 直接报错，num1 根本就没有isdecimal 这个方法
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
# True
# False
# False
# ''.isdigit() :bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
# True
# True
# False
# False
# isdigit() 字符串是否是数字， 直接 int() 非数字的字符串会直接报错
# 用来判断字符串是否是纯数字
age = input('>>>:')
if age.isdigit():
print(f"age = {age}")
else:
print("请好好输入")
# 后续代码待完善，用pass 顶一下，后续再写
pass # 在if、while、for中不知道写什么了，可以暂时用 pass 补全python代码块结构（搭框架，然后慢慢补充）不报错
查找指定元素在字符串中的索引
find index
s = '"kevin is dsb and kevin is sb"'
# find('dsb') # 返回的是d字符所在的索引值,找不到的时候不报错，返回的是 -1
# find('dsb', 0, 3) # 在 0 - 2（3, 顾头不顾尾） 的索引中查找字符（0, 3）限制查找范围
print(s.find('vin'))
print(s.rfind('vin'))
# 3
# 20
# index('0') # 返回所传字符所在的索引值，找不到的时候会在直接报错
# find('dsb', 0, 3) # 在 0 - 2（3, 顾头不顾尾） 的索引中查找字符（0, 3）限制查找范围
print(s.index('vin'))
# 3
print(s.rindex('vin'))
# 20
统计个数
count
# 统计所传参数在字符串中出现了几次
s = '"kevin is dsb and kevin is sb"'
print(s.count('vin'))
# 2
字符串格式化对齐
字符串格式化填充（对齐） center ljust rjust zfill
s = 'jason'
# center 把现在的字符串居中，其他的用指定字符在两遍填充，使其达到指定长度
print(s.center(40, '$')) # 不能左右平分的时候，右边会比左边多一个
print(s.ljust(40, '$'))
print(s.rjust(40, '$'))
print(s.rjust(40, ' ')) # 可以用在左对齐右对齐上
print(s.zfill(40)) # zfill z 表示zero 零
# $$$$$$$$$$$$$$$$$jason$$$$$$$$$$$$$$$$$$
# jason$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
# $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$jason
# 00000000000000000000000000000000000jason
转义字符知识扩展
\n 表示回车
string1 = '-a-\n-b-'
string2 = '-a-\r-b-'
print(string1)
print('--------------')
print(string2)
# -a-
# -b-
# --------------
# -b-
print()
# \r 表示将光标的位置回退到本行的开头位置（将控制台当前行删除）
print('-----------------', end='')
print('-a-', end='')
print('\r', end='')
print('-b-', end='')
# -b-
print()
# \b 表示将光标的位置回退一位(在控制台当前行最后删除一个字符)
print('-----------------***', end='')
print('\b\b|||')
# -----------------*|||
5. 列表
作用：记录多组数据，爱好
# 是否可变类型： 可变类型，可以通过索引改值（l[1] = 2）
# 是否有序：有序
# 定义：list内部原理就是for 循环取值，然后一个个塞到列表中去
list_a = [1, 2, 3, 4] # list_a = list([1, 2, 3, 4])
list_a = list('[1, 2, 3, 4]')
print(list_a)
# ['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']
list_a = list('1,2,3,4')
print(list_a)
# ['1', ',', '2', ',', '3', ',', '4']
list_a = list('1234')
print(list_a)
# ['1', '2', '3', '4']
切片
l = [1, 2, 3, 4]
print(l[0::])
# [1, 2, 3, 4]
# 第二参数不写默认到 最后一个，第三个参数不写默认是1
print(l[5::-1])
# [4, 3, 2, 1]
添加元素
append
l = [1, 2, 3, 4]
l.append(5)
print(l)
l = [1, 2, 3, 4]
l.append([5, 6, 7]) # 尾部添加元素，被添加的数据会被当做一个元素
print(l)
# [1, 2, 3, 4, [5, 6, 7]]
# insert(索引, 要添加的元素) -->通过索引往指定位置（索引处）添加
l = [1, 2, 3, 4]
l.insert(3, 'hello')
print(l)
# [1, 2, 3, 'hello', 4]
l = [1, 2, 3, 4]
l.insert(-1, [5, 6, 7]) # insert 意思是在某个索引前添加元素
# 被添加的数据会被当做一个元素
print(l)
# [1, 2, 3, [5, 6, 7], 4]
l = [1, 2, 3, 4]
l.insert(len(l), [5, 6, 7]) # 利用insert特点在列表最后追加元素
print(l)
# [1, 2, 3, 4, [5, 6, 7]]
# extend 将列表与另一个容器对象拼接
l = [1, 2, 3, 4]
l2 = ['hello', 'world']
l.extend(l2) # 将列表与另一个列表拼接，在后面追加 ---> 原理就是for循环一个个动态 append
# l.extend([1]) # 要用extand 添加单个元素，需要将其写成 容器类型（extend原理循环的对象必须是 容器类型）
# l.extend(1) # 会直接报错，因为 1 不是容器类型数据对象
print(l)
# [1, 2, 3, 4, 'hello', 'world']
l = [1, 2, 3, 4]
l2 = {'name': 'jason', 'age': 18}
l.extend(l2) # extend 字典对象，会将字典的key 作为元素添加与列表合并（list本质for循环，而字典在循环时暴露出来的是key ）
print(l)
# [1, 2, 3, 4, 'name', 'age']
l = [1, 2, 3, 4]
l.extend('helloworld') # extend str字符串类型，会将字符串每一个字符都单独作为一个元素与列表合并（str可以被for 循环迭代遍历）
print(l)
# [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']
删除元素
del 适用于所有的删除操作
l = [1, 2, 3, 4]
# print(del l[2]) # 会报错， del 没有返回值
del l[2]
print(l)
# [1, 2, 4]
# 删除其他类型举例
s = 'cvnm'
# print(del s) # 会报错， del 没有返回值
# del s
# print(s) # 会报错，因为s 已经被删掉了，现在s 是未定义的
pop与remove
pop 弹出，尾部弹出 pop有返回值，会打印当前弹出对象的值 ---> 可以用在注销登录时，可以获取到用户的用户名
l = [1, 2, 3, 4]
print(l.pop())
print(l)
# 4
# [1, 2, 3]
l = [1, 2, 3, 4]
print(l.pop(0)) # 可以指定弹出索引处的元素
print(l)
# 1
# [2, 3, 4]
# remove
l = [1, 2, 3, 4]
print(l.remove(1)) # 删除了已存在的元素返回 None， 不存在的元素会直接报错（ValueError: list.remove(x): x not in list）
# print(l.remove(6)) # remove一个不存在的值，直接报错
# print(l.remove()) # 直接报错，remove 必须传入一个要删除的元素
print(l)
# None
# [1, 3, 4]
列表与字符串互转
------------- 利用 str字符串的内置函数 split 与 join 完成 列表与字符串的互转 -----------
l = ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']
print(l)
# ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']
connect = '-我是连接符-'
print(connect.join(l))
# hello-我是连接符-thank-我是连接符-you-我是连接符-thank-我是连接符-you-我是连接符-very-我是连接符-much
'''
# 使用字符串的 join 方法将列表转成字符串
# 调用 .join 方法的对象就是 列表元素连接的连接符
'''
split_string = connect.join(l)
print(split_string)
print(split_string.split(connect))
# ['hello', 'thank', 'you', 'thank', 'you', 'very', 'much']
print(split_string.split(connect) == l)
# True