目录
- 一、与用户交互
- 二、格式化输出
- 三、基本运算符
- 四、常用赋值赋
- 五、逻辑运算符
- 六、成员运算符
- 七、身份运算符
- 八、基本数据类型
- 九、垃圾回收机制
- 十、流程控制
- 十一、数据类型内置方法
- 十二、可变类型和不可变类型
- 十三、字符编码理论
一、与用户交互
1.获取用户输入
input
# 获取用户输入
username = input('请输入您的用户名>>>:')
强调:input获取到的数据都会统一处理成 # 字符串类型
2.输出内部信息
print()
1）括号内既可以放数据值，也可以放变量名，并且支持多个数据值或者变量名，用逗号隔开即可
2） print 自带换行符
# 换行符：\r\n 或者\n（斜杠与字母组合可能会产生特殊含义）
3） print也可以切换结束符
print(数据，end='默认是\n')
二、格式化输出
提前定义好一些内容,将来需要使用的时候可以局部修改与填写
1.代码实现
在现实生活中大部分情况下使用下划线提示别人填写内容
但是在程序中需要使用占位符:%s %d
2.不同占位符的区别
# %s常见数据类型都支持
demo1 = '%s您好 您本月的话费是%s 余额是%s'
print(demo1 % ('jason', 100, 1))
# %d只支持数字类型
demo2 = '%d您好 您本月的话费是%d 余额是%d'
print(demo2 % ('tony', 1, -100))
三、基本运算符
1.数学运算符
# +、-、*、/、%、//、**
2.简化写法
n = 10
n += 1 # n = n + 1
n -= 1 # n = n - 1
n *= 1 # n = n * 1
n /= 1 # n = n / 1
n %= 1 # n = n % 1
n //= 1 # n = n // 1
n **= 1 # n = n ** 1
3.比较运算符
<、>、<=、>=、==(等于号)、!=(不等于号)
四、常用赋值赋
1.链式赋值
name = 'jason'
name1 = name
name2 = name
则链式赋值可以改写成：
name = name1 = name2 ='jason'
2.交叉赋值
m = 100
n = 999
#如何让m和n互相交换绑定的数据值
1）方法一：采用中间变量 做中介
temp = m
m = n
n = temp
print(m, n) # 999 100
2）方法二：交叉赋值语法 直接交换
m, n = n, m
print(m, n) # 999 100即交换成功
3.解压赋值```python
name_list = ['jason', 'sam', 'amy', 'jack']
#赋值语法
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']
五、逻辑运算符
1.and 与
and连接的多个条件必须全部成立，结果才能通过成立
1 > 2 and 4 < 8 and 10 < 1 and 1 == 2
如果条件中全部由and组成那么判断起来非常的简单 只要发现一个不成立 结果就不成立
2.or 或
or连接的多个条件只要有一个成立，结果就成立
#举例
1 > 2 and 4 < 8 and 10 < 1 and 1 == 2
如果条件中全部由or组成那么判断起来非常的简单，只要发现一个成立，结果就成立
3.not 非
取反
类似于说反话
六、成员运算符
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 列表最小单位是数据值 不能再细分
2）字符串中
s1 = 'hello world'
print('d' in s1) # 字符串最小单位是单个单个的字符
3）字典中
d1 = {
'username':'jason',
'pwd':123
}
print('jason' in d1) # False 字典成员运算只有键参与
print('username' in d1) # True
七、身份运算符
is 用于判断内存地址是否相同
== 判断数据值是否相同
'''
id() 返回一串数字，该数字可以看作是内存的地址
'''
八、基本数据类型
1.整型int
#整型int，即为整数
如：age = 18
2.浮点型float
#浮点型float，即为小数
如：weight = 66.6
3.字符串str
#字符串string，即为文本类型的数据值，一般用'' ""引号来创建字符串
如：name = 'qiuqiu'
4.列表list
#列表list，使用[ ]表达，多个值之间用逗号隔开，不限制数据类型
# 语法：列表名=[值1，值2]
如：l1 = [11, 11.11, 'jason',[11, 22]]
5.字典dict
# 以“键值对”的形式存放数据，key不能重复
能够非常精确的存储和表达数据值的含义
info_dict = {
'username': 'jason',
'age': 18,
'hobby': 'read',
}
1.字典文字描述 [key:value]
2.按Key取值
#字典只能按K取值 因为字典是无序的 没有索引的概念
6.布尔值bool
1.布尔值表示两个值之一 True or False
2.只有两种状态
True 对的
False 错的
3.python中所有的数据都自带布尔值
布尔值为 False的数据有： False 0 None '' [] {} ()
4.存储布尔值的变量名一般推荐使用is开头
is_delete = False
is_alive = True
7.元组tuple
# '不可变'的列表
t1 = (11, 22, 33)
print(t1[0])
t1[0] = 999
print(t1) # 则会报错：TypeError: 'tuple' object does not support item assignment
8.集合set
# 集合只能用于去重和关系运算
s1 = {1, 2, 3, 4, 5, 6}
set() 定义空集合
九、垃圾回收机制
1.引用计数
一个数据被引用时，其引用计数则会+1，而当其引用次数变为0时，将会把这个数据值当作垃圾删除掉。
2.标记清除 ==>解决循环引用占用内存
当内存占用达到临界值的时候，程序会自动扫描程序中所有的数据，并给只产生循环引用的数据打上标记之后一次性清除。
3.分代回收 ==>频繁更新引用计数会降低运行效率损，耗各项资源
十、流程控制
1.while循环
只要条件为真，while 就会一直重复执行那段代码块
1.while条件中的关键字
break 强行结束循环体
continue 直接跳到条件判断处
2.while else语句
else:
循环体代码没有被强制结束的情况下 执行完毕就会执行else子代码
3.嵌套及全局标志位
1）break的说明：
一个break只能结束它所在的那一层循环，有几个while的嵌套，就应该写几个break
2）标志位
如果不想反复写break 可以使用全局标志位，在我们需要结束循环的时候，可以改变标志的布尔值，从而结束循环。
2.for循环
for 变量名 in 待遍历的数据:
for循环体代码
1.for循环使用的主要场景为: 循环获取存储多个数据的数据内部数据值
2.for循环的特点
1）擅长遍历取值
2）不需要结束条件，遍历完可以自动结束循环
3.循环主要遍历的数据类型
1）数据类型有：字符串、列表、元组、字典、集合
2）应用特点：
（1）字符串：循环遍历的是单个的字符串
（2）字典：循环遍历的是各个键
4.break、 continue 、 else
break ：for循环体代码中如果执行到break也会直接结束整个for循环
continue ：for循环体代码中如果执行到continue也会结束当前循环直接开始下一次循环
else ：for循环体代码(没有被break强制结束的情况下)运行完毕之后运行else的代码
十一、数据类型内置方法
1.整型int
int(+其他数据类型)将其他数据类型转换成 整型int
# int可以将纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
二进制 bin
八进制 oct
十六进制 hex
2.浮点型float
float(+其类型的数据)
字符串里面可以允许出现一个小数点 其他都必须是纯数字
3.字符串str
str(+其类型的数据)
可以转换任何类型的数据（只要在前后加引号即可）
1.索引取值str[值1]
s1 = 'hello world'
print(s1[0]) # h
2.切片操作str[值1:值2]
str[值1:值2] 从 索引1 一直到索引 值2到前一位
print(s1[1:5]) # 顾头不顾尾，从索引1一直切取到索引4
3.修改切片方向（间隔/步长）
str[值1:值2:值3] # 从索引1一直到索引2，每次到步长为值3
print(s1[:]) # 不写数字就默认都要
print(s1[2:]) # 从索引2开始往后都要
4.统计字符串中字符的个数len
print(len(s1))
5.移除字符串首位指定字符.strip()
1）括号内不指定字符串时，默认移除首尾的空格不能移除字符串中间的同样字符
2）移除指定字符，可指定首部或尾部
首部 变量名.lstrip()
尾部 变量名.rstrip()
6.切割字符串中指定的字符 .split()
1）该方法处理的结果是一个列表
2）可以从左往右，或者从右往左选择切割个数
从右往左加r为 .rsplit()
从左往右， .split()本身就是从左往右切割
7.字符串格式化输出.format()
1）format等价于占位符
2）format索引取索引值
# {}中+索引值
res = 'rng has {0} tes has {1} edg has {2}'.format('breath','jackeylove','meiko')
3）format直接索引变量名
# {}中+变量名
res = 'rng has {rng} tes has {tes} edg has {edg}'.format(rng='breath',tes='jackeylove',edg='meiko')
4）format索引变量名 f+'字符串'用法
# 当变量名为动态时候，format占位 的 变量名 也会随之改变，比占位符号好用
8.其他方法
1）转换大小写upper与lower
2）判断字符串中是否是纯数字.isdigit()
# isdigit 的判断结果是布尔值
3）替换字符串中指定的内容.replace()
# 语句
.replace(被代替的字符, 代替的字符, 替换个数)
4）字符串的拼接+ 或者 * 或者.join()
（1）str1 + str2 + str3
# 多个字符串凭借可以直接相加
（2）str * 数字n 直接输出n遍 str
（3）.join()语句
# 字符串1+.join([str1,str2,...,strn])，将列表[]中的字符串，用字符串拼接起来
5）统计指定字符出现的次数.count()
字符串.count('字符')，统计该字符在字符串中出现的次数
6）判断字符串的开头或者结尾.startswith()和.endswith()
字符串.startswith/.endswith ('需要判断的某一个或多个字符')
其得到的结果是布尔值 True/False
7）.title() # 将字符串中的每个单词的首字母大写
8）.capitalize() # 将第一个单词的首字母大写
9）.swapcase() # 将字母的大小写反转
10）.index() # 查找字符，找不到直接报错
11）.find() # 查找字符，找不到会返回-1
4.列表list
list(+要转换的数据类型)
# 能够被for循环的数据类型都可以转换成列表：字符串、字典、元组、集合
1.索引取值(正负数) 同字符串
列表的变量名+[索引值]
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1[0]
2.切片操作 同字符串
列表的变量名+[索引值1:索引值2] # 左包含右不包含
l1[0:4]
3.间隔数 同字符串
列表的变量名+[索引值1:索引值2：步长]
l1[::-2] # 步长为负值，表示方向从右往左
4.统计列表中数据值的个数长度len()
len(l1)
5.数据值修改
列表变量名[索引值] = 要修改的值
l1[0] = 123 # 将索引0 修改成123
6.列表添加数据值.append()/.insert()/.extend()
1）尾部追加数据值 .append()
l1.append(123)
2）任意位置插入数据值 .insert()
列表名.insert(索引值,要插入该索引值的数据值)
l1.insert(0, 11111) # 将索引0插入 数据11111
3）扩展列表 合并列表 .extend()
# 语句
列表1+.extend(列表2)
print(ll1 + ll2) # [11, 22, 33, 44, 55, 66]
ll1.extend(ll2) # extend相当于 for循环+append
print(ll1)
------------------
[11, 22, 33, 44, 55, 66]
7.删除列表数据
1）通用的删除关键字 del
del +列表[索引值]
del l1[0]
2）删除括号内的数据值 .remove()
列表名.remove(要删除的数据值)
l1.remove('uZi') # 如果删除的是字符串，大小写要一致
3）括号内填写索引值 .pop()
列表名.pop(要删除的索引值)
l1.pop(1) # 删除索引值1 的数据值
8.排序.sort()
列表名+.sort() # 默认是升序
9.统计列表中某个数据值出现的次数.count()
列表名+.count(要统计的数据值)
10.颠倒列表顺序.reverse()
列表名+.reverse
5.字典dict
1.按key取值
字典名['k值']
2.按内置方法get取值
字典+ .get('要取的values的keys')
字典+ .get('要取的values','当不存在对应的keys时返回这串字符')
3.修改数据值
字典['要改变values的keys'] = '要改变的values'
当要改变的键存在 # 会直接改变这个键的数据值
4.新增键值对
字典['要增加的keys'] = '要增加的values' # 会直接在字典末尾增添新的键值对
5.删除数据del 、pop
1） del +字典['要删除的keys']
2） 字典.pop('要弹出的keys')
3） popitem() 用来随机删除一个键值对
6.统计字典中键值对的个数 len()
7.字典三剑客
1） 字典.keys() # 一次性获取字典所有的键
2） 字典.values() # 一次性获取字典所有的值
3） 字典.items() # 一次性获取字典的键值对数据
8.其他
1） .fromkeys 生成相同数据值不同键的字典
dict.fromkeys(['要生成的列表的keys'], 要生成的数据值values)
2） append 为数据值为空列表的时候添加数据值
3） detdefault 默认值 None
6.元组tuple
tuple() 支持for循环的数据类型都可以转换为元组
1.索引取值、切片间隔
1）索引取值
元组[索引值]
# 其中 索引值可以是正数也可以是负数 ，负数代表了方向从右往左
2）切片间隔
元组[起始索引:结束索引:步长step]
2.统计元组内数据值的个数len
3.统计元组内某个数据值出现的次数count
4.统计元组内制定数据值的索引值index
index访问元组中的某个元素,得到的是这个元素的索引值
5.关于元组的注意要点
1）元组内如果只要一个数据值那么逗号不能少
2）元组内索引绑定的内存地址不能被修改（注意区分 可变与不可变）
3）元组内不能新增或者删除数据
7.集合set
set() 集合常常应于 去重和关系运算
# 集合内数据必须是不可变类型(整型、浮点型、字符串、元组)
# 集合内数据也是无序的,没有索引的概念
1.去重
print直接打印就是去重
2.关系运算
l1 = {'jason', 'tony', 'jerry', 'oscar'}
l2 = {'jack', 'jason', 'tom', 'tony'}
求两个人的共同好友
print(l1 & l2)
求用于1独有的好友
print(l1 - l2)
求两个人所有的好友
print(l1 | l2)
求两个人独有的好友
print(l1 ^ l2)
交集 & 取两集合公共的元素 set1 & set2
并集 | 取两集合全部的元素 set1 | set2
差集 - 取一个集合中另一集合没有的元素 set1 - set2
对称差集 ^ 取集合 A 和 B 中不属于 A&B 的元素 set1 ^ set2
十二、可变类型和不可变类型
# 字符串在调用内置方法之后并不会修改自己，而是产生一个新的结果
# 列表在调用内置方法以后修改的就是自身，并没有产生一个新的结果
如何查看调用方法有没有新的结果，可以在调用该方法的代码左侧添加变量名和赋值符号
1.可变类型：数据值改变，内存地址不变：
列表，字典、集合
2.不可变类型：数据值改变，内存地址肯定变：
字符串
十三、字符编码理论
# unicode万国码
兼容所有国家语言字符，起步就是两个字节来表示字符
# utf系列:utf8 utf16 ...
专门用于优化unocide存储问题，英文还是采用一个字节，中文三个字节
1.编码与解码
编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
# 字符串.encode()
解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
# bytes类型数据.decode()