目录
一、习题详解
二、数据类型的内置方法理论
三、整型相关操作
四、浮点型相关操作
五、字符串相关操作
六、列表相关操作
今日详解
一、习题详解
1.计算1-100所有数据之和
all_num = 0
# 先定义记录数字之和为0的计数器
for i in range（1, 101）:
# 用昨天内容“range”循环绑定一个1---100的数值（骨头不顾尾）
all_num +=i # all_num = all + i
# 等待for循环运行结束 打印计数器
print(all_num) # 5050
2.判断列表中数字2出现的次数
l1 = 【11, 2, 3, 2, 2, 1, 2, 1, 2, 3, 2, 3, 2, 3, 4, 3, 2, 3, 2, 2, 2, 2, 3, 2】
# 先定义一个记录数字2出现次数的计数器
count_num = 0
# 循环获取列表中每一个数据半段是不是数字2
for i in l1:
#如果i绑定数据值是2，则让计数器自己增加1
if i ==2:
count_num += 1
# 等待for循环运行结束 打印计数器
print(count_num) # 13
3.编写代码自动生成所以页网址（注意总共多少页）
https://movie.douban.com/top250?start=0&filter=
https://movie.douban.com/top250?start=25&filter=
https://movie.douban.com/top250?start=50&filter=
# 找寻其规律等差25
base_ur1 = 'https://movie.douban.com/top250?start=%s&filter='
for i in range (0, 225,25):
print(base_ur1 % i)
4.编写代码打印出下列图形(ps:for循环嵌套)
*****
*****
*****
*****
for i in range(4): # 0 1 2 3 4次 4行
for k in range(5): # 0 1 2 3 4 5次 5列
print('*', end= '')
print()
二、数据类型内置方法理论
内置方法即是每个数据类型自带的功能
数据类型总类：
1.整型 2.浮点型 3.列表型 4.字典型
5.字符型 6.布尔值 7.元组 8.集合
使用数据类型的内置方法统一采用句点符（.）
如：'rain'. 字符串必备的方法()
name = 'rain'
name. 字符串必备的方法()
三、整型内置方法与操作
关键字：int()
整型就是整数 ，主要用于计算，没有内置方法
类型转换：int('代转换的数据')
# res = int(11.11) # 11 浮点型可以直接转换
# res = int(11.57) # 11 python自身对数字的敏感度较低(精确度低)，如果需要进准的计算需要借助于模块numpy.....
# res = int('11') # 11 字符串中纯数字可以转
# res = int('11.11') # 字符串中必须是纯数字才可以转否则报错
# print(res, type(res))
进制数转换如下：
print(bin(100)) #bin()将十进制转换为二进制 0b 是二进制的标识 0b1100100
print(oct(100)) #oct()将十进制转换为八进制 0o 是八进制的标识 0o144
print(hex(100)) #hex()将十进制转换为十六进制 0x 是十六进制的标识 0x64
-----------------------------------------------------------------------------
其他进制转十进制：
print(int(0b1100100))
print(int(0o144))
print(int(0x64))
print(int("0b1100100", 2))
print(int("0o144", 8))
print(int("0x64", 16))
四、浮点型内置方法与操作
关键字：float()
字符串里面可以允许出现一个小数点 其他都必须是纯数字
python自身对数字的敏感度较低(精确度低)，如果需要进准的计算需要借助于模块numpy.....
# res = float(11) # 11.0 整型可以直接转浮点型，自动填补.0
# res = float('11') # 11.0 字符串可以直接转，自动填补.0
# res = float('11.11') # 11.11 又一个小数点也可以转
# res = float('1.1.1.1') # 不行 说明只认识一个小数点
# res = float('abc') # 不行 说明只有数字字符串才可以转
# print(res, type(res))
字符串内置方法与操作
关键字：str()
类型转换：字符串可转换所有数据值(只需要在前后加引号即可)
转换的方法
1.索引取值 ： 单个字符 （支持负数）
s1 = 'Surprise' # 条件 （惊喜）
print(s1[0]) # S 单个字符去除
print(s1[-1]) # e 负数 从后往前
2.切片取值：多个字符 ，支持负数，切片的顺序默认为从左往右
s1 = 'Surprise' # 条件 （惊喜）
print(s1[1:5]) # urpr 顾头不顾尾 从索引1一直窃取到索引4 默认顺序从左往右
print(s1[-1:-5]) # 没有 默认顺序从左往右
print(s1[-5:-1]) # pris 默认顺序从左往右
切片取值时，顺序默认从左往右，当第三个参数赋值为-1时，循序变为从右往左打印，若没有给第三个参数赋
值则默认为1。取值的时候是遵循顾头不顾尾的原则，第二个参数数默认减一
3.修改切片方向(间隔)
s1 = 'Surprise' # 条件 （惊喜）
print(s1[1:5:1]) # urpr 默认是1不间隔 （顾头不顾尾）左到右 索引1到索引4
print(s1[1:5:2]) # up 默认是1 从索引1到索引4跳一个拿一个
print(s1[-1:-5:-1]) # esir 默认是-1 不间隔从右往左要到-4
print(s1[:]) # Surprise 不写数字就默认都要
print(s1[2:]) # rprise 从索引2开始往后都要
print(s1[:5]) # Surpr 从索引0开始往后要到4
print(s1[::2]) # Srrs 全都要每隔一个要一个
间隔方向默认为从左往右
4.统计字符串中字符的个数
s1 = 'Surprise' # 条件 （惊喜）
print(len(s1)) # 8 该字符串有8个字符组成
在使用len()统计字符个数时，其中的空格也在统计范围内
5.移除字符首尾指导的字符
s1 = ' Surprise ' # 条件 （惊喜）
print(len(s1)) # 10 该字符串10个字符组成，空格也算。
print(len(s1.strip())) # .strip括号内不写 默认移除首尾的空格
# res1 = '$$Surprise$$'
# print(res1.strip('$')) # Surprise 括号里有'$'移除所有
# print(res1.lstrip('$')) # Surprise$$ 括号里有'$'但是多了个字母“l”左，所以移除左边的'$'
# print(res1.rstrip('$')) # $$Surprise
运用字符串用内置的方法消除字符时，所表示的不是改变原始数据，而是产生了新的数据，随后输出来调用改
变后的数据
还可以进行左消除或者右消除操作：
即在strip前加l或者r
l即left 即左消除
r即right 即右消除
6.按照指定的字符切割字符串
res = 'ZGL|170|read'
print(res.split('|')) # ['jason', '123', 'read'] 该方法的处理结果是一个列表
name, pwd, hobby = res.split('|') # 赋值 切割
print(res.split('|', maxsplit=1)) # ['ZGL', '170|read'] 默认从左往右切指定个数
print(res.rsplit('|',maxsplit=1)) # ['ZGL|170', 'read'] 从右往左切指定个数
若出现连续的特征符号，考虑用切割操作。
使用切割字符串时，默认为从左往右切割，若split前由r时，则为从右往左切割
当需要切割次数时，使用maxsplit ，当后面的数值为多少就是需要切割多少次。
7.字符串大小写相关
res = 'hElLO WorlD 666'
print(res.upper()) # HELLO WORLD 666 全大写
print(res.lower()) # hello world 666 全小写
图片验证码:生成没有大小写统一的验证码 展示给用户看 获取用户输入的验证码 将用户输的验证码和当初产生的验证码统一转大写或者小写再比对
code = '8Ja6Cc'
print('展示给用户看的图片验证码', code)
confirm_code = input('请输入验证码').strip()
if confirm_code.upper() == code.upper():
print('验证码正确')
res = 'hello world'
print(res.isupper()) # 判断字符串是否是纯大写 False
print(res.islower()) # 判断字符串是否是纯小写 True
进行大小写的相关操作时，使用lower()或者upper()操作可将字符串中所由字母进行大小写转换，进而使大小写
穿插输入达到一致的结果。
若其前加is 则为判断该字符串是否是全大写，或者全是小写。
8.字符串的格式化输出
format玩法1:等价于占位符 # {} = %S\%d
res = 'my name is {} my age is {}'.format('jason', 123)
print(res)
format玩法2:索引取值并支持反复使用
res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
print(res)
format玩法3:占位符见名知意
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1} '.format(name1='jason', age1=123)
print(res)
format玩法4:推荐使用(******)不确定的因素占个位置
name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'
print(res)
# username>>>:zgl
# age>>>:18
my name is zgl my age is 18
用字符串替换格式化输出，有四种方式，与前三种相比较，在输出结果前加f操作更加方便快捷
9.判断字符串中是否为纯数字
res = ''
print(res.isdigit())
guess_age = input('guess_age>>>:').strip()
if guess_age.isdigit():
guess_age = int(guess_age)
else:
print('年龄都不知道怎么输吗???')
采用isdigit()方法对整型进行判断处理
10.字符串替换
res = 'my name is zgl zgl zgl zgl'
print(res.replace('zgl', 'tonySB')) # my name is tonySB tonySB tonySB tonySB tonySB 替换
print(res.replace('zgl', 'tonySB', 1)) # my name is tonySB jason jason zgl zgl 从左往右替换指定个数字符
（没有从右往左）
采用replace（）方法可以将字符串中的代码进行替换（遵循从左往右的原则）
在原数据，替换数据之后填写一个数据值则为替换间隔数（没有填写则默认为0）
11.字符串的拼接
ss1 = 'hello' # 条件
ss2 = 'world' # 条件
print(ss1 + '$$$' + ss2) # 两个条件拼接——相加
print(ss1 * 10) # 条件1×10
print('|'.join(['jason', '123', 'read', 'JDB']))
print('|'.join(['jason', 123])) # 直接报错，参与拼接的数据值必须都是字符串
字符串的拼接支持+ * 形式的拼接，拼接的结果为没有间隔的数据。
当使用join()方法进行拼接时，join前的单引号中若为|则使用|来将其拼接结果进行分割。若为空则视为没有间隔
列表中的数据都必须是字符串类型否则报错。
12.统计字符串中指定字符出现的次数
res = 'hello world'
print(res.count('l')) # 3 括号里是需要统计的东西
相比于循环操作，采用.count（）方法能够更加快捷的找到字符串中所需要的数据
13.判断字符串的开头或者结尾
res = 'zhanggaoli say hello' # 定义
print(res.startswith('zhanggaoli')) # True 开始.startswith
print(res.startswith('z')) # True 开始.startswith
print(res.startswith('zha')) # True 开始.startswith
print(res.startswith('h')) # False 不是开头
print(res.startswith('gao')) # False 不是开头
print(res.startswith('li')) # False 不是开头
print(res.endswith('o')) # True 结尾.endswith
print(res.endswith('llo')) # True 结尾.endswith
print(res.endswith('hello')) # True 结尾.endswith
print(res.endswith('l')) # False 拆开不是结尾
print(res.endswith('ell')) # False 、不是结尾
采用swith()方法判断字符串的开头或者结尾
swith前为start时是判断开头是否正确 可以是首字母，也可是前面的连续字母
swith前为end 时，则是判断结尾是否正确。可以是尾字母，也可以是最后的连续字母（这里是从左往右）
拓展补充方法
14.查找某个字符对应的索引值
res = 'hello world jason'
print(res.index('o')) # 10
print(res.find('j')) # 10
'''index查找索引 如果没有则报错'''
# print(res.index('d',0,5))
'''find查找索引 如果没有则返回-1'''
# print(res.find('d',0,5)) # -1
使用index()时，如果在字符串中没有找到对应字符，则返回一个报错
使用find()时，如果在字符串中没有找到对应字符，则返回-1，不抛出报错。
15.正文相关操作
res = 'My Name IS bACk'
print(res.title()) # My Name Is Back
print(res.capitalize()) # My name is back
print(res.swapcase()) # mY nAME is BacK
capitalize(): 字符串第一个字母大写
title(): 字符串内的所有单词的首字母大写
swapcase()：字符串内的所有大小写互换（原本大写打印出来就是小写，原本小写打印出来就是大写）
五、列表内置方法及操作
关键字：list（）
类型转换：
能够被for循环的数据类型都能转换成列表
print(type(list(数据 )))
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']
print(list({'name': 'jason', 'pwd': 123})) # ['name', 'pwd']
print(list((1, 2, 3, 4))) # [1, 2, 3, 4]
print(list({1, 2, 3, 4, 5})) # [1, 2, 3, 4, 5]
方法与字符类型转换方法相同
11 = [111, 222, 333, 444, 555, 666, 777, 888]
# 1.索引取值(正负数)
# print(l1[0])
# print(l1[-1])
# 2.切片操作 与字符串讲解操作一致
# print(l1[0:5])
# print(l1[:])
# 3.间隔数 方向 与字符串讲解操作一致
# print(l1[::-1])
# 4.统计列表中数据值的个数
# print(len(l1)) # 8
# 5.数据值修改
# l1[0] = 123
# print(l1)
# 6.列表添加数据值
# 方式1:尾部追加数据值
# l1.append('干饭')
# print(l1) # [111, 222, 333, 444, 555, 666, 777, 888, '干饭']
# l1.append(['jason', 'kevin', 'jerry'])
# print(l1) # [111, 222, 333, 444, 555, 666, 777, 888, ['jason', 'kevin', 'jerry']]
# 方式2:任意位置插入数据值
# l1.insert(0, 'jason')
# print(l1)
# l1.insert(1, [11, 22, 33, 44])
# print(l1) # [111, [11, 22, 33, 44], 222, 333, 444, 555, 666, 777, 888]
# 方式3:扩展列表 合并列表
# ll1 = [11, 22, 33]
# ll2 = [44, 55, 66]
# print(ll1 + ll2) # [11, 22, 33, 44, 55, 66]
# ll1.extend(ll2) # for循环+append
# print(ll1) # [11, 22, 33, 44, 55, 66]
# for i in ll2:
# ll1.append(i)
# print(ll1)
# 7.删除列表数据
# 方式1:通用的删除关键字del
# del l1[0]
# print(l1)
# 方式2:remove
# l1.remove(444) # 括号内填写数据值
# print(l1)
# 方式3:pop
# l1.pop(3) # 括号内填写索引值
# print(l1)
# l1.pop() # 默认尾部弹出数据值
# print(l1)
# res = l1.pop(3)
# print(res) # 444
# res1 = l1.remove(444)
# print(res1) # None
# 8.排序
# ss = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
# ss.sort() # 默认是升序
# print(ss)
# ss.sort(reverse=True)
# print(ss) # 改为降序
# 9.统计列表中某个数据值出现的次数
# print(l1.count(111))
# 10.颠倒列表顺序
# l1.reverse()
# print(l1)
可变类型与不可变类型
l1 = [11, 22, 33]
s1.strip('$')
print(s1) # $$jason$$
字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果
如何查看调用方法之后有没有新的结果 可以在调用该方法的代码左侧添加变量名和赋值符号
“res = s1.strip('$')”
ret = l1.append(44)
print(l1) # [11, 22, 33, 44]
print(ret) # None
列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果
可变类型:值改变 内存地址不变
l1 = [11, 22, 33]
print(l1)
print(id(l1))
l1.append(44)
print(l1)
print(id(l1))
不可变类型:值改变 内存地址肯定变
res = '$$hello world$$'
print(res)
print(id(res))
res.strip('$')
print(res)
print(id(res))
