数据类型与内置方法
- 字符串操作与内置方法
(1).类型转换
str(其他数据类型)
ps：可以转任意数据类型（只需要在前后加引号即可）
1. 移除字符串首位的指定字符，可以选择方向 strip rstrip lstrip
s1 = '$$$jason$$$'
print(s1.strip('$'))# 去除首尾空格，移除字符串中首位指定字符jason
print(s1.rstrip('$')) # 移除左边指定的字符$$$jason
print(s1.lstrip('$'))#移除右边指定的字符jason$$$
2.大小写相关操作 lower
s2 = 'JaSoN666Sb'
print(s2.lower())# 将所有的英文字母变为小写
print(s2.upper())#将所有的英文字母变为大写
print(s2.islower())#判断字符串中所有的英文字母是否是纯小写
print(s2.isupper())#判断字符串中所有的英文字母是否为大写
3.判断字符串的开头或者结尾是否是指定的字符 startswith endwith
s3 = 'jason kevin jason tong 666'
print(s3.startswith('j')) #判断开头是否是j开头，答案True
print(s3.endswith('6'))#判断结尾是否6结尾，答案True
4.格式化输出 format
# 方式1：占位符:%s %d
# 方式2： format 方法的四种玩法
# 玩法1：跟占位符一样，使用{}占位
print('my name is {} my age is {}'.format('mm',18))
#玩法2：根据索引取值 可以反复使用
print('my name is {0} my age is {1} '.format('jason',20))
#玩法3 根据指名道姓的方法取值
print('my name is {name} my age is {age}'.format(name='jason',age = 18))
#玩法4：直接使用已经出现过的变量******
name = 'jason'
age = 12
print(f'my name is {name}c,my sge is {age}')
5.拼接字符串 join
s1 = '三月不努力 四月变垃圾'
s2= '年少不努力 妄为少年人'
#print(s1+s2) #如果字符串很大 ，加号效率较低
# print （s1 * 10）#重复次数
print('|'.join(s1))
#三|月|不|努|力| |四|月|变|垃|圾
print('$'.join(['jason','kevin','justin','tony']))
#jason$kevin$justin$tony
# join的元素必须都是字符串才可以，不然会报错 *****
6.替换字符串中指定的字符 replace
s4 = ' jason tong beat jason age'
print(s4.replace('age','18')) #必须是字符串才可以，数字也得加引号，不然报错
print(s4.replace( 'jason','18' ,2))
# 还可以通过数字控制替换的个数，从左往右*** 没有从右往左的
7. 判断字符串中是否是纯数字 isdigitt
s5 = 'jason666.666'
print(s5.isdigit()) #里面是纯数字就True，带小数点就False
8.判断数据的值有多少？ len 数数*****
print(len(s5))
# 所有的数据类型都可以使用
- 整型操作与内置方法
1.类型转换（将其他数据类型转换成整型）
int（其他数据类型）
ps：浮点型可以直接转，字符串必须满足内部是纯数字才可以
2.进制数转换
十进制转其他进制
print(bin(100)) # 0b1100100
print (oct(100))#0o144
print(hex(100))#0x64
'''
数字开头如果是0b则为二进制，0o则为八进制，0x则为十六进制
'''
其他进制转十进制
print(int(0b1100100))
print(int(0o144))
print(int(0x64))
答：print(int("0b1100100",2))
print(int("0o144",4))
print("0x64",16)
3.python语言自身对数字的敏感度比较低
如果需要进准的计算需要借助于模块numpy....
- 浮点型操作与内置方法
1.类型转换 float(其他数据类型) 字符串里面可以允许出现一个小数点，其他都必须是纯整数
2.python自身对数字的敏感度较低（精准度低） 如果需要进准的计算需要借助于模块numpy....
列表操作与内置方法
类型转换 list()必须要掌握的操作
1.索引取值
l1=[111,222,333,444,555,666,777,888]
print(l1[0]) #111 从开头开始
print(l1[-1])#888 从后往前开始# 列表索引取值支持负数
2.切片操作
l1=[111,222,333,444,555,666,777,888]
print(l1[0:5])#[111,222,333,444,555] 顾头不顾尾
print(l1[:])#[111,222,333,444,555,666,777,888]
#取所有
l1=[111,222,333,444,555,666,777,888]
print(l1[::-1])
# [888,777,666,555,444,333,222,111]反过来取
3.统计列表中数据值的个数
len（）
l1=[111,222,333,444,555,666,777,888]
print(len(l1)) #8
4.数据值更改
l1=[111,222,333,444,555,666,777,888]
l1[0]=123
print(l1)#[123,222,333,444,555,666,777,888]
#数据更改通过索引更改
5.列表添加数据值
方法一：尾部追加数据值
l1=[111,222,333,444,555,666,777,888]
l1.append('hello')
print(l1)
#[111,222,333,444,555,666,777,888,'hello']
方法二：任意位置添加数据值
l1.append([1,'world'])
print(l1)#从指定索引值添加指定数据值
#[111,222,333,444,555,666,777,888,['jason','kevin','jerry']]
方法三：扩展列表，合并列表
ll1=[11,22,33]
ll2=[44,55,66]
111.extend (112)
print(ll1)# [11,22,33,44,55,66]
6.删除列表数据
方式一：通用的删除关键字del
del l1[0]
print(l1)# [222,333,444,555,666,777,888]
方式二：remove
l1=[111,222,333,444,555,666,777,888]
l1.remove(444) #括号内填写数据值
print(l1) # [111,222,333,555,666,777,888]
方式三：pop
l1=[111,222,333,444,555,666,777,888
l1.pop(3)#括号内填写索引值,不填写默认尾部弹出数据值
print(l1)#[111,222,333,555,666,777,888]
pop与remove的区别
res = l1.pop(3)
print(res)# 444
resl = l1.remove(3)
print(resl) # None
'''使用pop会返回删除数据的值 remove不会返回值'''
7.排序
ss = [99,44,77,11,88]
ss.sort()# 默认是升序
print（ss）#[11,44,77,88,99]
ss.sort(reverse=True)#改为降序
print(11.count(11)) #[99,88,77,44,11]
8.统计列表中某个数据值出现的次数
11 = [11,44,55,11,88,11]
print(11.count(11)) #3
9.颠倒列表的顺序
11= [11,44,55,11,88,11]
11.reverse()
print(11)
#[11,88,11,55,44,11]
- 字典操作与内置方法
1.类型转换
dict()
字典的转换一般不使用关键字 而是自己动手转
2.字典必须要掌握的操作
user_dict = { 'username': 'jason', 'password': 123,
'hobby': ['read', 'music', 'run'] }
1.按k取值(不推荐使用)
print(user_dict['username']) # jason
print(user_dict['phone'])
k不存在会直接报错
2.按内置方法get取值(推荐使用)
print(user_dict.get('username'))
jason
print(user_dict.get('age'))
None
print(user_dict.get('username', '没有哟 嘿嘿嘿'))
jason 键存在的情况下获取对应的值
print(user_dict.get('phone', '没有哟 嘿嘿嘿'))
键不存在默认返回None 可以通过第二个参数自定义
3.修改值数据
print(id(user_dict))
user_dict['username'] = 'tony'
键存在则修改对应的值
print(id(user_dict))
print(user_dict)
4.新增键值对
user_dict['age'] = 18
键不存在则新增键值对
print(user_dict)
5.删除数据
del user_dict['username']
print(user_dict)
res = user_dict.pop('password')
print(user_dict)
print(res)
123
6.统计字典中键值对的个数
print(len(user_dict)) # 3
7.字典三剑客
print(user_dict.keys()) # 一次性获取字典所有的键 dict_keys(['username', 'password', 'hobby'])
print(user_dict.values()) # 一次性获取字典所有的值 dict_values(['jason', 123, ['read', 'music', 'run']])
print(user_dict.items()) # 一次性获取字典的键值对数据 dict_items([('username', 'jason'), ('password', 123), ('hobby', ['read', 'music', 'run'])])
for i in user_dict.items():
k, v = i # print(k, v)
8.补充说明
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123)) # 快速生成值相同的字典
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res) # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('jason')
res['pwd'].append(123)
res['hobby'].append('study')
print(res)
'''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
res = user_dict.setdefault('username','tony') print(user_dict, res) # 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age',123)
print(user_dict, res) # 存不存在则新增键值对 结果是新增的值
user_dict.popitem() # 弹出键值对 后进先出
- 元组操作与内置方法
1.类型转换
tuple()
ps:支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
# 1.索引取值
# 2.切片操作
# 3.间隔、方向
# 4.统计元组内数据值的个数
# print(len(t1)) # 6
# 5.统计元组内某个数据值出现的次数
# print(t1.count(11))
# 6.统计元组内指定数据值的索引值
# print(t1.index(22))
# 7.元组内如果只有一个数据值那么逗号不能少
# 8.元组内索引绑定的内存地址不能被修改(注意区分 可变与不可变)
# 9.元组不能新增或删除数据
集合操作与内置方法
1.类型转换
set()
集合内数据必须是不可变类型(整型 浮点型 字符串 元组)
集合内数据也是无序的 没有索引的概念
2.集合需要掌握的方法
去重
关系运算
ps:只有遇到上述两种需求的时候才应该考虑使用集合
3.去重
s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l1 = list(s1)
print(l1)
'''集合的去重无法保留原先数据的排列顺序'''
4.关系运算
群体之间做差异化校验
eg: 两个微信账户之间 有不同的好友 有相同的好友
f1 = {'jason', 'tony', 'jerry', 'oscar'} # 用户1的好友列表
f2 = {'jack', 'jason', 'tom', 'tony'} # 用户2的好友列表
# 1.求两个人的共同好友
# print(f1 & f2) # {'jason', 'tony'}
# 2.求用户1独有的好友
# print(f1 - f2) # {'jerry', 'oscar'}
# 3.求两个人所有的好友
# print(f1 | f2) # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
# 4.求两个人各自独有的好友
# print(f1 ^ f2) # {'oscar', 'tom', 'jack', 'jerry'}
# 5.父集 子集
print(f1 > f2)
print(f1 < f2)
- 数据类型元组
用来判断事物的对错
如果想表示布尔值变量名可以加is
True 对的，可行的
False 错的，不可行的
例如："""
很多程序中提供的注销账户的功能 其实底层并没有删除数据 而是修改了数据的状态
id username password phone is_delete
1 jason 123 110 1
2 kevin 321 120 0
"""
python中所有数据都自带布尔值
布尔值为False的数据有:0 None '' [] {}
布尔值为True的数据有:除了上面的都是True
存储布尔值的变量名一般推荐使用is开头
is_delete = False
is_alive = True
可变与不可变类型
可变类型
值改变 内存地址不变
不可变类型
值改变 内存地址肯定变
可变数据类型是当该数据类型对应变量的值发生变化时，对应内存地址并没有开辟新的内存
'''列表，字典是可变类型'''
11 = [11,22,33]
print(id(11))
11.append(44)
print(11)# [11,22,33,44]
print(id(11))
不可变数据类型是当该数据类型对应变量的值发生变化时，原来内存中的值不变，而是会开辟一块新的内存，变量指向新的内存地址
'''整型，浮点型，布尔值，字符串，元组，都是不可变类型'''
res= '$$hello world$$'
print(res)#$$hello world$$
print(id(res))
res = res.strip('$')
print(res)# hello world
print(id(res))
与用户交互
input (输入)，print(输出)
- 获取用户输入
1.先执行input获取用户输入
2.将输入的数据绑个变量名
input获取到的数据都会统一处理成字符串类型
输出(print)
1.括号内既可以放数据，也可以放变量名，逗号间隔开就好
2.换行，\n，简单方便
3.print也可以切换换行符
python2与python3中两个关键字的区别
python2中
input方法需要用户自己提前指定数据类型 写什么类型就是什么类型
raw_input方法与python3中input一致 输入的统一处理成字符串
python2中
print方法有两种使用方式
print 数据值
print(数据值)
格式化输出
%s:可以替然后数据类型占位
%d：只能替数字占位(占位符不管是多还是少，有几个占位符就需要几个数据值)
%09d：print('%09d' %12)000000012
代码示范： dasc = '姓名：%s 年龄：%s 爱好：%s'
print( dasc %('jason',12,13))
基本运算符
1.数学运算符
+ - * / % // **
简化写法
n = 10
n += 1 # n = n + 1 (20)
n -= 1 # n = n - 1 (10)
n *= 1 # n = n * 1 (10)
n /= 1 # n = n / 1 (10)
n %= 1 # n = n % 1 (0)
n //= 1 # n = n // 1 (10)
n **= 1 # n = n ** 1 (10)
2.比较运算符
< > <= >= ==(等于号) !=(不等于)
常用赋值符
1.交叉赋值
让m和n互相转换绑定的值
m = 100
n = 99
m , n = n , m
print(m,n)
2.链式赋值
是指在一条链上
name = 'jason'
name1 = name
name2 = name1
name3 = name2
name4 = name3
name = name1 = name2 =name3 =name4 =name
3.解压赋值
name_list = ['jason', 'kevin', 'tony', 'oscar']
'''low的写法'''
name1 = name_list[0]
name2 = name_list[1]
name3 = name_list[2]
name4 = name_list[3]
'''解压赋值语法'''
name1, name2, name3, name4 = name_list
'''解压赋值在使用的时候 正常情况下需要保证左边的变量名与右边的数据值个数一致'''
a, b = name_list # 变量名少了不行
a, b, c, d, e = name_list # 变量名多了也不行
'''当需要解压的数据个数特别多 并且我们只需要使用其中的几个 那么可以打破上述的规则'''
a, *b = name_list # *会自动接收多余的数据 组织成列表赋值给后面的变量名
print(a) # jason
print(b) # ['kevin', 'tony', 'oscar']
a, c, *b = name_list
print(a)
print(c)
print(b) # ['tony', 'oscar']
a, *b, c = name
逻辑运算符
and 与
and 链接多个条件 必须都成立
or 或
not 非 就是相反的
这个就是有一个条件，成立或者不成立，能够判断了之后就不继续执行了
'''
print(1 <10 and 666 and 1<4) #输出结果只看最后一个条件的类型
'''
成员运算符
1.判断个体在不在群体内
name_list = ['jason', 'kevin', 'oscar', 'jerry'] print('tony' in name_list) # False
print('tony' not in name_list) # True
print('j' in name_list) # False 列表最小单位是数据值
身份运算符
is ：判断内存地址是否相同
== ：判断数据值是否相同
"""
值相同 内存地址可能不同
内存地址相同 值肯定相同
"""
垃圾回收机制
有一些语言，内存空间的申请和释放都需要程序员自己写代码才可以完成，但是python却不需要，通过垃圾回收机制自动管理
1.引用计数
l1 = [11, 22] # 引用计数为1
l2 = [33, 44] # 引用计数为1
l1.append(l2) # l1 = [11, 22, l2列表] 引用计数为2
l2.append(l1) # l2 = [33, 44, l1列表] 引用计数为2
del l1 # 断开变量名l1与列表的绑定关系 引用计数为1
del l2 # 断开变量名l2与列表的绑定关系 引用计数为1
当数据值身上的引用计数为0的时候，就会被当成垃圾一样回收
当数据值身上的引用计数不为0的时候，永远不会被垃圾回收机制回收
2.标记清除
主要针对循环引用问题
当内存占用达到临界值的时候，程序会自动停止，然后扫描程序中所有的数据
并给只产生循环引用的数据打上标记，之后一次性清理
3.分代回收
垃圾回收机制的频繁运行也会损耗各项资源
新生代，青春代，老年代(越往下检测频率越低)
4.缺点
该机制所带来的额外操作和需要回收的内存块成正比.
流程控制理论知识
流程控制：就是控制事物的执行流程
事物执行流程总共可以分为三总
1.顺序结构
从上往下依次执行，我们之前所编写的代码都属于该结构
2.分支结构
事物的执行会根据条件的不同做出不同的执行策略
3.循环结构
事物的执行会根据某个条件出现重复
1.python中使用代码缩进来表示代码的从属关系,缩进量一般为四个空格
从属关系：缩进的代码（子代码）是否执行取决于上面没有缩进的
2.并不是所有的代码都可以拥有缩进的代码（就是拥有子代码）
3.如果有多行子代码属于同一个父代码，那这些子代码需要保证是相同的缩进量
4.当某一行代码需要编写子代码的时候，那么这一行代码的结尾肯定需要冒号
5.相同缩进量的代码彼此之间平起平坐（同一排），安照顺序结构依次执行
分支结构
1.单if分支结构if语句：只有当指定条件为true时，这语句才会执行代码，在条件是false是在执行其他代码2.if- else 双分支双分支语句是两个互相排斥条件（两个条件一定会满足一个，不会同时满足，也不会同时不满足）3.if-else if-else多分支1.多分支所有的大括号代码最多也只会执行一个，只有当前面的条件不满足，才会到后面的条件判断2.多分支一定要以if开头，后面else if可以多个，结尾else可以省略
代码展示：
1.单if分支结构
if 条件:
条件成立之后才会执行的代码快
ps:单if可以借助于流程图理解
username = input('username>>>:')
if username == 'jason':
print('老师好')
2.if...else...双分支结构
if 条件: 条件成立之后执行的子代码 else: 条件不成立执行的子代码
username = input('username>>>:')
if username == 'jason':
print('老师好')
else:
print('去你妹的')
3.if...elif...else多分支结构
if 条件1:
条件1成立之后执行的子代码 elif 条件2:
条件1不成立 条件2成立执行的子代码
elif 条件3:
条件1和2都不成立 条件3成立执行的子代码 else:
上述条件都不成立 执行的子代码
ps:中间的elif可以写多个、上述子代码永远只会走一个 score = input('请输入学生成绩>>>:')
score = int(score) # 将字符串的整数转换成整型的整数
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('一般')
elif score >= 60:
print('及格')
else:
print('挂科 交钱重修')
4.if的嵌套使用
age = 28
height = 170
weight = 110
is_beautiful = True
is_success = False
username = 'tony'
if username == 'tony':
print('tony发现目标')
if age < 30 and height > 160 and weight < 150 and is_beautiful:
print('大妹纸 手机掏出来 让我加微信') if is_success:
print('吃饭 看电影 天黑了...') else:
print('去你妹的 流氓!!!') else:
print('不好意思 认错人了')
else:
print('不是tony做不出来这件事')
while循环结构
就是重复反复不停的循环
其中break的作用是可以跳出最内层的循环（即结束脱离循环）然后继续执行循环之后的代码。
（如果代码中包含多层循环，break只结束脱离最内层的循环）
continue的作用是可以结束本次单个循环，但是不结束脱离循环，然后继续执行该循环。
while 条件：循环体代码
else: 循环体代码没有被强制结束的情况下，执行完毕就会执行else子代码
1.死循环 真正的死循环是一旦执行，CPU会直线上升，直到系统采取紧急措施 尽量不要让死循环长时间运行 2.嵌套及全局标志位
1.记住一个break只能结束它所在的那一层循环
2.有几个while的嵌套循环，想一次性结束，就应该写几个break
3.如果不想反复写break，可以使用全局标志位
全局标志位代码演示
is_flag =True
while is_flag:
username = input('username:')
password = input('password:')
if username == 'jason' and password =='123':
while is_flag :
cmd = input('请输入您的指令：')
if cmd == 'q':
is_flag = False
print('正在执行您的指令：%s'% cmd)
else:
print('用户名或者密码错误')
代码演示
count = 1
while count < 5:
print('hello world')
count += 1 # count = count + 1
print('想不想干饭?')
流程控制之for循环
for 循环能够做到的事情while都可以做到，只不过for在一些场景下使用更方便
主要场景是：循环获取存储多个数据的数据内部数据值
实际案例：
循环打印出列表中每一个数据值(while 索引取值>>>:超出范围会报错)
name_list = ['jason', 'kevin', 'tony', 'oscar']
count = 0
while count < 4:
print(name_list[count])
count += 1
for循环
for i in name_list:
print(i)
for循环语法结构
for 变量名 in 待遍历的数据:
for循环体代码
for循环特点
1.擅长遍历取值
2.不需要结束条件 自动结束(遍历完)
for循环主要遍历的数据类型有(常见有 字符串、列表、元组、字典、集合)
info = 'hello world'
for i in info:
print(i) # 单个单个字符
d = {'username': 'jason', 'password': 123}
for i in d:
print(i) # 只有键参与遍历
for循环语法结构中的变量名如何命名
1.见名知意
2.如果遍历出来的数据值没有具体的含义 可以使用常用的
i j k item v
for循环体代码中如果执行到break也会直接结束整个for循环
for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
for 变量名 in 待遍历的数据:
for循环体代码
else:
for循环体代码没有被break强制结束的情况下运行完毕之后 运行
range方法
range可以简单的理解为是帮我们产生一个内部含有多个数字的数据
for i in range (101): #起始位置为0，终止位置为100
print（i）#[0~100]
for i in range (10,20): # 第一个起始位置 第二个终止位置
print (i)
for i in range (1,20,2): # 第三个数为等差值，默认不写为1
print（i）
"""
在python2中
range（）直接产生一个列表，内部含有多个数值xrange()
其实就是python3 里面的range
在python3中
range（）
类似于一个工厂，不会占用太多的内存空间，要就生产，不要就不生产
"""