Python学习笔记2

运算符

比较（关系）运算符

== 比较的是两个变量的值是否相等，相等返回为True（真），不相等返回为False（假）

!= 比较的是两个变量的值是否相等，不相等返回为True（真），相等返回为False（假）

<、>、<=、>=

逻辑运算符

and（与）左右两边都要符合才为真

or（或）左右两边只需要一边符合就为真

not（非）相反的结果

三目运算（三元表达式）

为真结果 if 判断条件 else 为假结果

例：

print("a小于等于b") if a <= b else print("a比b大")

 if判断

基本格式：

if 要判断的条件:
    条件成立的时候要做的事情

if-else--------------二选一

基本格式：

if 条件:
    满足条件时要做的事情
else:
    不满足条件时要做的事情

else后面不需要添加任何条件

if-elif----------------多选一

if 条件1:
    满足条件1要做的事情
elif 条件2:
    满足条件2要做的事情
elif 条件3:
    满足条件3要做的事情

if-elif-else

if 条件1:
    满足条件1要做的事情
elif 条件2:
    满足条件2要做的事情
elif 条件3:
    满足条件3要做的事情
else:
    以上条件都不满足

if嵌套

if里面有if

外层的if判断，也可以是if-else

内层的if判断，也可以是if-else

if 条件1:
    事情1
    if 条件2:
        事情2
else:
    不满足条件做的事

循环语句

while循环

while条件:
    循环体（条件满足时做的事情）
    改变变量


# 死循环 只要条件不是False或0，其他单独存在的值也会死循环
while True:
    循环体（要循环做的事情）

while循环嵌套

缩进决定层级，严格控制缩进，最好自动缩进

while 条件1:
    条件1满足时要做的事1
    条件2满足时要做的事2
    ······
    while 条件2:
        条件2满足时要做的事1
        条件2满足时要做的事2
        ······
        改变变量2
    改变变量1

for循环

for 临时变量 in 可迭代对象:
    循环满足条件执行的代码
# 冒号和缩进必须注意！

range()用来记录循环次数，相当于一个计数器，遵循包前不包后规则

里面只写一个数字，这个数就是循环的次数，默认从0开始；写两个数，前面的数字代表开始位置，后面的数字代表结束位置

# 1-5 相当于[1, 6)
range(1, 6)
# 0-4 5是循环次数
range(5)

break和continue关键字

都是专门在循环中使用的关键字，只能放在循环里面

break

某一条件满足时，退出循环，结束break所在的循环

continue

退出本次循环，下一次循环继续执行，在continue之前，一定要修改计数器，否则会陷入死循环

字符串

字符串编码

本质上就是二进制与语言文字的一一对应关系

ASCII编码、GB2312（国家简体中文字符集）、Unicode（所有字符都是两个字节，字符与数字之间转换速度更快一些但占用空间大）、UTF-8（精准，对不同的字符用不同的长度表示，节省空间，但字符与数字的转换速度较慢，每次都需要计算字符要用多少个字节来表示）

字符串编码转换

编码：encode()

        将其他编码的字符串转换成Unicode编码

解码：decode()

        将Unicode编码转换成其他编码的字符串

a = 'hello'
print(a, type(a))       # str, 字符串是以字符为单位进行处理
a1 = a.encode()         # 编码
print('编码后：', a1)
print(type(a1))         # bytes，以字节为单位进行处理
a2 = a1.decode()        # 解码
print(a2, type(a2))
# 对于bytes，只需要知道它跟字符串类型之间的相互转换

字符串的常见操作

字符串运算符

操作符	描述
+	字符串连接
*	重复输出字符串，需要输出多少次，*后面就写多少
[]	通过索引获取字符串中字符
[ : ]	截取字符串中的一部分
in	成员运算符---如果字符串中包含给定的字符返回True
not in	成员运算符---如果字符串中不包含给定的字符返回True
r/R	原始字符串---所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。除在字符串的第一个引号前加上字母“r”或“R”以外，与普通字符串有着几乎完全相同的语法。

下标/索引

Python中，下标从0开始，通过下标能够快速找到对应的数据

格式：字符串名[下标值]

从右往左数，下标从-1开始，-1，-2 ···

切片

对操作的对象截取其中一部分的操作

格式：[开始位置:结束位置:步长]

包前不包后，从起始位置开始，到结束位置的前一位结束（不包含结束位置本身）

步长：表示选取间隔，不写步长，默认为1

步长的绝对值大小决定切取的间隔，正负号决定切取方向

正数表示从左往右取值，负数表示从右往左取值

st = "abcdefghijk"
# 从左往右
print(st[0:4])        # abcd
print(st[4:7])        # efg
print(st[3:])         # defghijk   -----下标为3之后的全部截取到
print(st[:7])         # abcdefg    -----下标为7之前的全部截取到
# 从右往左
print(st[-1:])        # k
print(st[:-1])        # abcdefghij
priny(st[-1:-5])      # 未设定步长，切取方向不一致，结果为空

其他操作

find(子字符串, 开始位置下标, 结束位置下标)：

检测字符是否包含在字符串中

开始和结束位置下标可以省略，表示在整个字符串中查找

包前不包后

name = "abcdabcd"
print(name.find('b'))        # 1 -----第一个b的下标为1
print(name.find('abcd'))     # 0 -----第一个abcd，a的下标为0
print(name.find('b', 3))     # 5 -----从下标为3开始往后找
print(name.find('b', 6))     # -1 ----不包含返回-1
print(name.find('b', 3, 5))  # 4 -----在下标3-5位置范围内查找
# 包前不包后
print(name.find('b', 3, 4))  # -1

index(子字符串, 开始位置下标, 结束位置下标)：

检测某个子字符串是否包含在字符串中，如果在就返回这个子字符串开始位置的下标，否则就会报错

开始和结束位置下标可以省略，表示在整个字符串中查找

包前不包后

name = "为你，千千万万遍"
print(name.index("你"))        # 1
print(name.index("你", 2))     # 报错
print(name.index("你", 1, 3))  # 1

count(子字符串, 开始位置下标, 结束位置下标)：

返回某个子字符串在整个字符串中出现的次数，没有就返回0

开始和结束位置下标可以省略，表示在整个字符串中查找。

name = "abcdabcd"
print(name.count("a"))        # 2
print(name.count("e"))        # 0 
print(name.count("a", 1)      # 1
print(name.count("a", 1, 4))  # 0 ----- 同样遵循包前不包后

replace(旧内容, 新内容, 替换次数)：

替换次数可以省略，默认全部替换

split(ch, num)：

ch指定分隔符来切字符串，以列表的形式返回

如果字符串中不包含分割内容，就不进行分割，会作为一个整体

num指定分割几次

其他

capitalize：首字母大写

startswith(子字符串, 开始位置下标, 结束位置下标)：是否以某字母开头

endswith(子字符串, 开始位置下标, 结束位置下标)：是否以某字母结束

isupper()：检测字符串中所有的字符是否为大写，是的话就返回True

lower：大写字母转小写

upper：小写字母转为大写

列表

是处理一组有序项目的数据结构

列表名 = [元素1, 元素2, 元素3, 元素4...... ]

元素之间的数据类型可以各不相同

列表也可以进行切片操作

列表是可迭代对象，可以for循环遍历取值

相关操作

添加元素

append()        extend()        insert()

li = ['one', 'two', 'three']
# li.append('four')    # ['one', 'two', 'three', 'four'] append整体添加
# li.extend('four')    # ['one', 'two', 'three', 'f', 'o', 'u', 'r'] extend分散添加
# li.extend('4')       # 报错，extend中只能是可迭代对象
li.insert(2, 'four')   # ['one', 'two', 'four', 'three'] 在指定位置插入元素，不能不指定位置

修改元素

直接通过下标就可以进行修改

查找元素

in：判断指定元素是否存在列表中，如果存在就返回True，不存在就返回False

not in：判断指定元素是否存在列表中，如果不存在就返回True，存在就返回False

index、count

删除元素

del

li = ['a', 'b', 'c', 'd']
# del li        # 删除整个列表
del li[2]       # 根据下标删除

pop：删除指定下标的数据，python3版本默认删除最后一个元素

li = ['a', 'b', 'c', 'd']
# li.pop()        # 默认删除最后一个元素
li.pop(2)         # 不能指定元素删除，只能根据下标进行删除，下标不能超出范围

remove：根据元素的值进行删除

li = ['a', 'b', 'c', 'd', 'b']
# li.remove('b')     # 默认删除最开始出现的指定元素
li.remove('t')       # 报错，列表中不存在这个元素

排序

sort：将列表按特定顺序重新排列，默认从小到大

reverse：倒序，将列表倒置（反过来）

列表推导式

格式一：[表达式 for 变量 in 列表]

注意：in后面不仅可以放列表，还可以放range()，可迭代对象

格式二：[表达式 for 变量 in 列表 if 条件]

把技术放进列表里面

列表嵌套

一个列表里面又有一个列表