数据类型

1. 整型（int）

主要是用于数字计算

1.1 十进制转二进制

采用"除2取余，逆序排列"法

方法：用十进制数除2，得到的商再除2，直到商为小于1时为止，然后把先得到的余数逆序依次排列起来，就是有效位的二进制数。

1.2 二进制转十进制

二进制数从右到左用去乘以对应的乘积，结果相加就是对应的十进制数

二进制数	0	0	1	0	1	0	1	0
对应乘法	2^7	2^6	2^5	2^4	2^3	2^2	2^1	2^0
对应乘积	128	64	32	16	8	4	2	1
结果	0	0	32	0	8	0	2	0

二进制数1 对应的乘积有数，0 对应的乘积得零

0010 1010 → (转十进制) → 42

1.3 int 操作方法

计算整数化二进制的长度

格式：变量名.bit_length()：计算整数转化为的二进制码的长度

num = 10
print(num.bit_length())  # 当十进制用二进制表示时，最少使用的位数
# 运行结果: 4

2. 布尔型（bool）

布尔值就两种正确与否：True，False

人类语言	二进制	python语法
真	1	True
假	0	False

int → str

数字以字符串的格式输出

i1 = 100
print(str(i1))      # '100'     #包含转换语法

str → int

只能是纯数字组成的字符串转成数字

s1 = '666'
s1_int=int(s1)      # 转换语法
print(s1_int)       # 666

int → bool

False：0和空，True：非0和非空

# print(bool(135))         # True
# print(bool(0))           # False

bool → int

False：0，True：1

print(int(True))        # 1
print(int(False))       # 0

str → bool

False：空，True：非空

print(bool('太帅'))       # True
print(bool(''))          # False

bool → str

以字符串显示（无意义）

print(str(True))       # 'True'
print(str(False))      # 'False'

3. 字符串（str）

可以存储少量的数据并进行相应的操作

3.1字符串相加

也就是字符串拼接，必须都是字符串才能相加，不能相减

a = '世界'
b = '你好'
print(a + b)   # 结果:世界你好

3.2 字符串相乘

字符串和数字相乘，不能相除

a = '坚强'
print(a * 3)   # 结果:坚强坚强坚强

3.3 索引

对字符串进行索引排号，又之为下标

name = 'meet'
# 索引： 0123
print(name[3])    #结果：t

倒序

从右向左倒序排列

name = 'meet'
# 索引 -4-3-2-1
print(name[-1])    #结果：t

3.4 切片

选择字符串中提取一段字符输出

格式：变量名[头索引:尾索引]

原则：顾头不顾尾，尾索引要+1

# 从索引0开始获取到索引3结束，切片中终止位置减1。
name = 'meet'
# 索引： 0123
print(name[0:3])   # 结果：mee

3.5 步长

控制切片里输出字符间隔的长度

格式：变量名[头索引:尾索引:步长]：中间必须使用英文分号

# 例1
name = 'meet'
# 索引  0123
print(name[0:3:1])   # 结果：mee

解析：括号中第三位写了步长为1，和之前没写没有变化，因为不写的时候步长默认为1。

# 例2
name = 'meating'
# 索引： 0123456
print(name[0:5:2])   # 结果：mai

理解：从起点开始走每间隔一位输出下一位，也就是每次迈步的长度为2，一直走到终点结束，输出中间所有被踩到的字符。（迈步的长度简称步长）

解析：起点为0，终点为5，步长为2。索引0加上步长2就找到了索引2，索引2再加上步长2就是索引4，由于终止是索引5，不够再有下次的步长，就终止查找。最后结果就是：mai

倒序排列

切片倒序输出，索引从右往左负数切片，步长也必须为负

原则：顾头不顾尾，尾索引要-1

s = 'hello你好'
print(s[-1:-3:-1])      # 切片倒序输出每位
print(s[-3:-8:-2])      # 切片倒序每间隔一位输出

总结

索引：s[index]                          # index：下标
切片：s[start_index:end_index+1]        # 顾首不顾尾
切片步长：s[start_index:end_index+1:2]          # 默认为1可不写，2：每间隔一位输出
倒序切片步长：s[-strat_index:-end_index-1:-1]    # 切片倒序为负索引，步长为负

3.6 str 操作方法

以下操作不会对原字符串进行任何改变，只是产生一个新的字符串

转换大、小写

变量名.upper('转换对象')：转换大写

变量名.lower('转换对象')：转换小写

注意：转换大小写只作用对于英文

s = 'taiBAifdsa'
s1 = s.upper()        # 把这个字符串全部转换大写
s2 = s.lower()        # 把这个字符串全部转换小写
print(s1,s2)

应用场景：验证码

username = input('用户名：')
password = input('密码：')
code = 'QwEr'
print(code)
your_code = input('不区分大小写验证码：')
if your_code.upper() == code.upper():    # 如果输入的验证码的大写版与设定的验证码大写版相等
    if username == '小王' and password == '123':
        print('欢迎')
    else:
        print('用户名密码错误')
else:
    print('验证码错误')

首字母大写

变量名.capitalize()：将字符串的首字母大写，生成一个新的字符串（中文没有效果）

name = 'alexdasx'
new_name = name.capitalize()    # 转换首字母大写
print(new_name)                 # 结果：Alexdasx

大小写相互转换

变量名.swapcase()：将大写的字母转换为小写，小写的换为大写（中文没有效果）

name = 'AHDDdsnda'
new_name = name.swapcase()     # 大小写转换
print(new_name)                # 结果：ahddDSNDA

判断开头、结尾

变量名.startswith('判断对象')：判断以什么字符为开头

变量名.endswith('判断对象')：判断以什么字符为结尾

注意：判断结果返回布尔值（True/False）

s = 'taiBAifdsa'
new_name = name.startswith('t')   # 括号内设置判断条件，是否以t为开头
print(new_name)           # 返回：True 
print(s.endswith('a'))        # 是否以a为结尾，返回：True
print(s.endswith('i',2,6))        # 切片判断，返回：True

字符串替换

变量名.replace(替换谁,替换成谁,替换次数)：替换、代替内容

msg = 'wang很nbwang很帅wang有钱'
msg1 = msg.replace('wang','小王')     # 替换wang为小王，默认全部替换
# 结果：小王很nb小王很帅小王有钱
msg2 = msg.replace('wang','小王',2)     # 替换wang为小王，从左至右替换2次
# 结果：小王很nb小王很帅wang有钱（只替换了前两个）
print(msg1,msg2)

.replace(' ','')        # 将所有空格替换成空

去除

变量名.strip()：括号内为空默认去除空格

s = '\n你好\t'      # \n：换行 \t：空四格（等效Tab）
print(s)
s1 = s.strip()      # 去除s内两边的空格
print(s1)

变量名.strip('去除指定字符')：可乱序排列指定去除字符

注意：遇空格停下，必须是与首、尾字符顺序或倒序挨着的才可一起除去，不可单独去除

s = 'abcde你好fg'
print(s.strip())          # 默认去除所有空格
print(s.strip('abc'))     # 去除指定字符
print(s.strip('好cbagf你'))    # 可乱序排列指定去除字符

分割

变量名.split()：括号内为空默认按照空格分割，字符串返回列表

知识点：分割是对字符串进行切片，且可以指定分隔n+1个字符串（非常重要）

str ---> list：字符串转列表

s1 = '你好 我好 他好'     # 默认按照空格分隔
print(s1.split())      # 结果：['你好', '我好', '他好']标准列表格式

变量名.split('指定分隔符')：指定分隔符符号，以指定的符号来分割字符串，返回列表

s1 = '你好#我好#他好'
s = s1.split('#')         # 指定以#为分隔符
print(s)               # 结果：['你好', '我好', '他好']

变量名.split('指定分隔符',分割次数)：控制分割次数，其余的相同符号可不分割

s1 = ':你好:我好:他好'
s = s1.split(':',2)       # 指定以冒号为分隔符，只分割2次
print(s)               # 结果：['', '你好', '我好:他好']

连接

'连接符号'.join(变量名)：每个字符之间用指定的连接符号接合起来

注意：列表里面的元素必须都是str类型才能连接

s1 = 'alex'
s2 = '+'.join(s1)          # 每个字符之间用加号连接起来
print(s2)               # 结果：a+l+e+x

list ---> str：列表转字符串

s1 = ['你好', '我好', '他好']       # 前提：列表里面的元素必须都是str类型
s = ':'.join(s1)                # 把每个元素以冒号连接
print(s)                        # 结果：你好:我好:他好

s = ['你好', '我好', '他好']       # 字符串列表格式
s1 = ''.join(s)                  # 以空连接所有字符
print(s1)                        # 结果：你好我好他好

计数

变量名.count('某字符',索引,索引)：计算字符串中某字符出现的次数

注意：返回结果的数字为int整型

s = 'sdfsdagsfdagfdhgfhg'
s1 = s.count('d')         # 计算s出现的次数
print(s1, type(s1))    # 结果：4 表示出现了4次，这里的数字是int类型
print(s.count('d',0,4))  # 结果：2 计算前5位d出现的次数

查找下标

变量名.find('某字符')：查找某字符的索引下标是多少，查不到的数就返回-1（整型）

name = 'alexdasx'
new_name = name.find('e')   # 通过元素查找下标,不存在就返回-1
print(new_name)

字符串格式化

'字符串{}字符串{}'.format('内容', '内容')：与%s用法基本相同

msg = '我叫{}今年{}性别{}'.format('大壮', 25, '男')  # 括号内容顺序填入对应大括号中
print(msg)     # 结果：我叫大壮今年25性别男

'字符串{0}字符串{1}字符串{0}'.format('内容0', '内容1')：对内容进行排号，序号可重复用

msg = '我叫{0}今年{1}性别{2}我依然叫{0}'.format('大壮', 25, '男')
print(msg)     # 结果：我叫大壮今年25性别男我依然叫大壮

'字符串{age}字符串{sex}字符串{name}字符串{age}'.format(sex='内容', age=数字, name= 变量名)：

指定对应变量名，可重复用，可对应变量

a = 18
msg = '我叫{name}今年{age}性别{sex}我依然叫{name}'.format(age=a, sex='男', name='大壮')
print(msg)    # 结果：我叫大壮今年18性别男我依然叫大壮

is 系列

变量名.isalnum()：判断字符串是否由字母或数字组成

变量名.isalpha()：判断字符串是否只由字母组成（中文也算）

变量名.isdecimal()：判断字符串是否只由十进制（数字）组成

注意：判断结果返回布尔值，（有符号或空格结果：False）

name = 'taibai123'
print(name.isalnum())     # 结果：True
print(name.isalpha())      # 结果：False（中文：True）
print(name.isdecimal())     # 结果：False

获取长度

len(变量名)：获取字符串的长度是多少

name = "Meet"
print(len(name))   # 结果:4

练习：换行打印每一个字符

s = '今天又是元气满满的一天'
count = 0
while count < len(s):     # len：获取可迭代对象的元素（字符串）总个数
    s1 = s[count]       # 索引序号变量
    print(s1)
    count += 1

for 循环

for 变量 in iterable: 可迭代的：iterable

循环输出每一个可迭代对象的元素（字符串）为变量，循环一边为止（有限）

搭配：break、continue、for else: 、while else:用法一样

s = '今天又是元气满满的一天'
for s1 in s:
    print(s1)

for循环是可以循环的数据结构：字符串(str)、列表(list)、元祖(tuple)、字典(dict)、集合(set)

唯独不能进行循环的是：整型(int)、布尔值(bool)

第三章 数据类型（一）