目录
单行注释和多行注释
- python 语言允许在任何地方插入空字符或注释，但不能插入到标识符和字符串中间
- 单行注释
- 使用 # 号标识单行注释的开始，跟在 # 号后面知道这行结束为止的代码都将被解释器忽略
- 多行注释
- 是指一次性将程序中的多行代码注释掉（使用三个引号或三个双引号将注释的内容括起来）
- 单行注释
# 这是一行简单的注释
print('Hello World')
"""
这里面的内容是多行注释
python语言真的很简单
"""
'''
print("这行代码被注释了，将不会被编译，执行")
'''
变量
- 使用等号（=）作为赋值运算符，
- python 是弱类型，弱类型语言有两个典型特征
- 变量类型无需声明即可直接赋值：对一个不存在的变量赋值就相当于定义了一个新的变量
- 变量的数据类型可以动态改变：同一个变量可以一会被赋值为整数，一会被赋值为字符串
python 是弱类型语言
a = 5 # 存入了一个变量 a，该变量 a 的值为 5
print(a) # 查看该变量 a 的值
a = 'Hello world' # 改变变量 a 的值，只要将新的值赋值给（装入）变量 a 即可，新赋的值会覆盖原来变量 a的值
print(a) # 查看该变量 a 的值
print(type(a)) # 查看变量 a 的类型
print 函数输出变量
# print(value, ..., sep='', end='\n', file=sys.stdout, flush=False)
user_name = 'CharLie'
user_age = 8
print('读者名:', user_name, '年龄:', user_age) # Value参数可以接受任意多个变量或值，因此 print() 函数完全可以输出多个值
print('=' * 90) # 分割
# print() 函数默认以空格隔开多个变量，如果希望改变默认的分割符号，可通过 sep 参数进行设置
print('读者名:', user_name, '年龄:', user_age, sep='|')
print('=' * 90) # 分割
# print()函数输出之后总是会换行，这是因为print()函数的end参数的默认值是"\n"
print(40, \t, end="")
print(50, \t, end="")
print(50, \t, end="") # 不换行输出
# file参数指定 print()函数的输出目标，file参数的默认值为 sys.stdout（代表系统标准输出，也就是屏幕，因此 print()函数默认输出到屏幕）
f = open('poem.txt', 'w') # 创建文件对象
print('沧海月明珠有泪', file=f) # 将结果输出到 f文件对象
print('蓝天日暖玉生烟', file=f)
f.close() # 关闭文件对象
变量的命名规则
- 在使用标识符时，需要注意:
- 可以由字母，数字，下划线(_)组成，其中数字不能打头
- 标识符不能是 python 关键字，但可以包含关键字
- 标识符不能包含空格
Python的关键字和内置函数
- python 还包含一系列关键字和内置函数，一般也不建议使用它作为变量名
- 如果开发者尝试使用关键字作为变量名，python解释器会报错
- 如果开发者使用内置函数的名字作为变量，python解释器不会报错，只是该内置函数就被这个变量覆盖了，该内置函数就不能使用了
数值类型
整型 int
a = 56
print(a)
a = 99999999999999999999999999 # 为 a 赋值一个大整数
print(a)
print(type(a)) # type() 函数用于返回变量的类型
a = None # python 的整型支持 None 值(空值)
print(a)
- python 的整型数值由 4 种表示形式
- 十进制形式: 最普通的整数就是十进制形式的整数
- 二进制形式: 以 0b 或 OB 开头的整数就是二进制形式的整数
- 八进制形式: 以 0o 或 0O 开头的整数就是八进制形式的整数(第二个字母是大写或小写的 O)
- 十六进制形式: 以 0x 或 0X 开头的整数就是十六进制形式的整数，其中 10~15 分别以 a~f (不区分大小写)来表示
# 以 0x 开头 0X 开头的整型数值是十六进制形式的整数
hex_value1 = 0x13
hex_value2 = 0XaF
print('hex_value1: ', hex_value1)
print('hex_value2: ', hex_value2)
# 以 0b 或 0B 开头的整型数值是二进制形式的整数
bin_val1 = 0b111
print('bin_val: ', bin_val1)
bin_val1 = 0B101
print('bin_val1: ', bin_val1)
# 以 0o 或 0O 开头的整型数值是八进制形式的整数
oct_val = 0o54
print('oct_val: ', oct_val)
oct_val = 0O17
print('oct_val: ', oct_val)
# 为了提高数值（包括浮点型）的可读性，python3允许为数值(包括浮点型)增加下划线作为分割符
# 在数值中使用下划线
one_million = 1_000_000 # 实际的值为 1000000
print(one_million)
price = 234_234_234 # 实际的值为 234234234
android = 1234_1234 # 实际的值为 12341234
浮点型
# 浮点型数值用于保存带小数点的数值，python的浮点数有两种表达形式
# - 十进制形式: 浮点数必须包含一个小数点，否则会被当成整数类型处理
# - 科学计数形式: 只有浮点型数值才可以使用科学计数形式表示
# python 不允许除于 0， 不管是整型值还是浮点型值，python都不允许除以 0
af1 = 5.2345556
print('af1: ', af1)
af2 = 25.2345
print('af2: ', af1)
print('af2 的类型: ',type(af1))
f1 = 5.12e2
print('f1: ', f1)
f2 = 5e3
print('f2: ', f2)
print('f2 的类型: ',type(f2))
复数
# python 甚至可以支持复数，复数的虚部用 j 或 J 来表示
# 如果程序中需要对复数进行计算，导入 python 的 cmath 模块（c 代表 complex），在该模块下包含了各种支持复数运算的函数
ac1 = 3 + 0.2j
print(ac1)
print(type(ac1))
ac2 = 4 - 0.1j
print(ac2)
print(type(ac2))
# 复数运算
print(ac1 + ac2)
# 导入 cmath 模块
import cmath
# sqrt() 是 camth 模块下的函数, 用于计算平方根
ac3 = cmath.sqrt(-1)
print(ac3)
字符串入门
字符串和转义字符
# 字符串既可以用单引号括起来，也可以用双引号，这没有任何区别
str1 = '单引号'
str2 = "双引号"
print(str1)
print(str2)
# 如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理
# - 使用不同的引号将字符串括起来
# - 对引号进行转义
# 使用不同的引号将字符串括起来
str3 = "I'm a coder" # 字符串中包含单引号
str4 = 'I"m a coder' # 字符串中包含双引号
# 使用转义字符，python允许使用反斜线(\)将字符串中的特殊字符进行转义
s1 = '"we are scared, Let \'s hide in the shade", says the bird' # 包含单引号，又包含双引号
拼接字符串
# 将两个字符串紧挨着写在一起，python就会自动拼接它们
# 只是书写字符串的一种特殊方法，并不能真正用于拼接字符串
s1 = "Hello,""Charlie"
print(s1)
# + 号作为字符串的拼接运算符
s2 = "python "
s3 = "is Funny"
# 使用 + 拼接字符串
s4 = s2 + s3
print(s4)
repr 和字符串
# python 不允许直接拼接数值和字符串，程序必须先将数值转换成字符串
# 将数值转换成字符串，可以使用 str() 或 repr() 函数
s1 = "这本书的价格是: "
p = 99.8
# 使用 str() 将数值转换成字符串
print(s1 + str(p))
# 使用 repr() 将数值转换成字符串
print(s1 + repr(p))
print('=' * 150) # 分割
# str() 和 repr() 函数都可以将数值转换成字符串，
# str 本身是 python 内置的类型(和 int / float一样)
# repr 只是一个函数，repr还有一个功能，它会以 python 表达式的形式来表示值
st = "I will play my fife"
print(st) # 如果直接使用 print() 函数输出字符串，将只能看到字符串的内容，没有引号
print(repr(st)) # 使用 repr() 函数对字符串进行处理，然后再使用 print() 执行输出，将可以看到带引号的字符串--这就是字符串的 python 表达式形式
# 在 python 交互式解释器中输入一个变量或表达式时
# python 会自动使用 repr() 函数处理该变量或表达式
使用 input 获取用户输入
# input() 函数用于向用户生成一条提示，然后获取用户输入的内容
# input() 函数总是返回一个字符串
msg = input('请输入你的值: ')
print(type(msg))
print(msg)
# 无论输入哪种内容，始终可以看到 input() 函数返回字符串，程序总会将用户输入的内容转换成字符串
# python2.x 提供了一个 raw_input() 函数，该 raw_input() 函数就相当于 python3.x中的 input 函数
# python2.x 也提供了一个 input() 函数，该 input() 函数比较怪异:
# - 要求用户输入的必须是符合 python 语法的表达式
# - 比如输入字符串必须使用双引号，否则会报错
长字符串
# 多行注释时提到使用三个引号(单引号，双引号都可以)来包含注释内容，其实这是长字符串的写法
# 如果所定义的长字符串并没有赋值给任何变量，那么这个字符串就相当于被解释器忽略了，也就是相当于注释掉了
# 使用三个引号括起来的长字符串完全可以赋值给变量
s = """Let 's go fishing:, said Mary.
"OK, Let's go", said her brother.
they walked to a lake"""
print(s)
# python还允许使用转义字符(\)对换行符进行转义，转义之后的换行符不会"中断"字符串
s2 = """The quick brown fox \
jumps over the lazy dog"""
print(s2)
# 程序如果需要对 python 表达式进行换行，同样需要使用转义字符(\)进行转义
num = 20 + 3 / 4 + \
2 * 3
# 20 + 3 / 4 + 2 * 3
print(num)
print(20 + 3 / 4 + 2 * 3)
原始字符串
# 原始字符串
# 字符串中的反斜线都有特殊的作用，因此当字符串中包含反斜线时，就需要对其进行转义
# 原始字符串以 "r" 开头，原始字符串不会吧反斜线当成特殊字符
s1 = r'G:\publish\codes\02\2.4'
print(s1)
# 如果原始字符串中包含引号，程序同样需要对引号进行转义(否则python同样无法对字符串的引号精确配对)
# 此时用于转义的反斜线会变成字符串的一部分
s2 = r'"let \'s go", said Charlie'
print(s2)
# 原始字符串中的反斜线会对引号进行转义，因此原始字符串的结尾处不能是反斜线 --- 否则字符串结尾处的引号就被转义了，这样就导致字符串不能正确结束
# - 不要使用原始字符串，而是改为使用长字符串的写法(三引号字符串)
# - 将反斜线单独写
s3 = r"Good Morning""\\" # python 会自动将这两个字符串拼接在一起
print(s3)
字节串 Bytes
# 字符串(str) 由多个字符组成，以字符为单位进行操作
# 字节串(bytes) 由多个字节组成，以字节为单位进行操作
# bytes 和 str 除操作的数据单元不同之外，它们支持的所有方法都基本相同，bytes也是不可变序列
# bytes 对象只负责以字节（二进制格式）序列来记录数据
# 如果采用合适的字符集，字符串可以转换成字节串， 字节串也可以恢复成对应的字符串
# bytes 对象可用于在网络上传输数据，也可以用于存储各种二进制格式的文件，比如图片，音乐等文件
# 如果希望将一个字符串转换成 bytes 对象:
# - 字符串内容都是 ASCII 字符，则可以通过直接在字符串之前添加 b 来构建字节串值
# - 调用 bytes()函数（其实是bytes构造方法）将字符串按指定字符集转换成字节串，如果不指定字符集（默认utf-8）
# - 调用字符串本身的 encode() 方法将字符串按指定字符集转换成字节串，如果不指定字符集，默认使用 utf-8 字符集
b1 = bytes() # 创建一个空的 bytes
b2 = b'' # 创建一个空的 bytes
b3 = b'Hello' # 通过 b 前缀指定 Hello 是 bytes 类型的值
print(b1)
print(b2)
print(b3)
# 调用 bytes 方法将字符串转换成 bytes 对象
b4 = bytes('我爱 python 编程', encoding='utf-8')
print(b4)
# 利用字符串的 encode() 方法编码成 bytes 默认使用 utf-8 字符集
b5 = "学习 python 很有趣".encode('utf-8')
print(b5)
# 字符串和字节串十分相似，只是字节串里的每个数据单元都是 1 字节
# 计算机中底层有两个基本概念:
# - 位(bit) / 字节(Byte),其中 bit 代表 1 位，要么是 0 要么是 1
# - byte 代表 1 字节，1 字节包含 4 位（bit）
# 如果程序获得了 bytes 对象，也可调用 bytes 对象的 decode() 方法将其解码成字符串
st = b5.decode('utf-8')
print(st)
# 字符集概念
# 计算机底层并不能保存字符，但程序总是需要保存各种字符
# - 为每个字符编号，当程序要保存字符时，实际上保存的是该字符的编号
# - 当程序读取字符时，读取的其实也是编号，接下来要去查 ”编号-字符对应表"(简称码表) 才能得到实际字符
# - 所谓的字符集，就是所有字符的编号组成的总和
# 美国人给英文字符，数字，标点符号等字符进行了编号， 1 字节（8位，支持 256 个字符编号）即可为所有字符编号 --- 这就是 ASCII 字符集
# 美国人又为世界上所有书面语言的字符进行了统一编号， 2 字节（16位，支持 65536 个字符编号）这就是 Unicode 字符集
# 实际使用的 UTF-8，UTF-16 等其实属于 Unicode 字符集
# 同一个编号在不同字符集中代表的字符完全有可能是不同的。
# 对于同一个字符串，如果采用不同的字符集来生成 bytes 对象，就会得到不同的 bytes 对象
深入使用字符串
转义字符
| 转义字符 | 说明 |
|---|---|
| \b | 退格符 |
| \n | 换行符 |
| \r | 回车符 |
| \t | 制表符 |
| \“ | 双引号 |
| \’ | 单引号 |
| \ | 反斜线 |
s = 'Hello\nCharlie\nGood\nMorning' # 换行符
print(s)
print('=' * 90) # 分割
s2 = '商品名\t\t单价\t\t数量\t\t总价' # 制表符
s3 = '疯狂python讲义\t108\t\t2\t\t216'
print(s2)
print(s3)
字符串格式化
| 转换说明符 | 说明 |
|---|---|
| d,i | 转换为带符号的十进制形式的整数 |
| o | 准换位带符号的八进制形式的整数 |
| x | 转换为带符号的十六进制形式的整数 |
| X | 转换为带符号的十六进制形式的整数 |
| e | 转化为科学计数法表示浮点数(e 小写) |
| E | 转化为科学计数法表示浮点数(E 大写) |
| f, F | 转化为十进制形式的浮点数 |
| g | 智能选择使用 f 或 e |
| G | 只能选择使用 F 或 E 格式 |
| C | 转换为单字符（只接受整数或单字符字符串） |
| r | 使用 repr()将变量或表达式转换为字符串 |
| s | 使用 str() 将变量或表达式转换为字符串 |
num = -28
print("num is: %6i" % num)
print("num is: %6d" % num)
print("num is: %6o" % num)
print("num is: %6x" % num)
print("num is: %6X" % num)
print("num is: %6s" % num)
# 字符串制定了最小宽度为6，因此程序转换数值时总宽度为6，程序自动在数值面前补充了三个空格
# 转换出来的字符串总是右对齐的，不够宽度时左边补充空格
# python 允许在最小宽度之前添加一个标志来改变这种行为
# - : 指定左对齐
# + : 表示数值总要带着符号 （正数带"+"，负数带"-"）
# 0 : 表示不补充空格，而是补充 0
# 这三个标志可以同时存在
num2 = 30
# 最小宽度为6，左边补0
print("num2 is: %06d" % num2)
# 最小宽度为6，左边补0，总带上符号
print("num2 is: %+06d" % num2)
# 最小宽度为6，左对齐
print("num2 is: %-6d" % num2)
print('=' * 150)
# 对于转换浮点数，python还允许指定小数点后的数字位数
# 如果转换的是字符串，python 允许指定转换后的字符串的最大字符数，这个标志被成为精度值，该精度值被放在最小宽度之后，中间用点 (.) 隔开
my_value = 3.001415926535
# 最小宽度为8，小数点保留后 3 位
print("my_value is: %8.3f" % my_value)
# 最小宽度为8，小数点保留后 3 位 左边补0
print("my_value is: %08.3f" % my_value)
# 最小宽度为8，小数点保留后 3 位 左边补0，始终带符号
print("my_value is: %+08.3f" % my_value)
print('=' * 150)
the_name = "Charlie"
# 保留三个字符
print("the_name is: %.3s" % the_name)
# 保留二个字符，最小宽度为10
print("the_name is: %10.2s" % the_name)
序列相关方法
# 序列相关方法
# 程序允许通过索引来操作字符，比如获取指定索引处的字符，获取指定字符在字符串中的位置等
# python 字符串直接在方括号([])中使用索引即可获取对应的字符
# - 字符串中的第一个字符的索引为 0，第二个字符的索引为 1... 以此类推
# python 也允许从后面开始计算索引
# - 最后一个字符串的索引为 -1，倒数第二个字符的索引为 -2... 以此类推
s = '0123456789'
print(s[2]) # 获取索引为 2 的字符
print(s[-4]) # 获取索引为 -4 的字符
print('=' * 90)
# 范围获取
print(s[3:5]) # 获取索引从 3开始 到 5结束 的字符
print(s[3:-5]) # 获取索引从 3开始 到 -5结束 的字符
print(s[-6: -3]) # 获取索引从 -6开始 到 -3结束 的字符
print('=' * 90)
# 省略起始索引或结束索引
# - 省略起始索引，从字符串开始处开始截取
# - 省略结束索引，截取到字符串结束处
print(s[5:])
print(s[-6:])
print(s[:5])
print(s[:-6])
print('=' * 90)
# in 运算符判断是否包含某个子串
s1 = 'very good'
print('very' in s1)
print('fkit' in s1)
print('=' * 90)
# 全局内置的 min() 和 max() 函数获取字符串中最小字符和最大字符
print(max(s1)) # 最大字符
print(min(s1)) # 最小字符
大小写相关方法
# python 字符串由内建 str 类代表
# - dir(): 列出指定类或模块包含的全部内容（包括函数，方法，类，变量等）
# - help(): 查看某个函数或方法的帮助文档
# for func in dir(str):
# print(func)
# help(str.__add__)
# print('=' * 90)
# title(): 将每个单词的首字母改为大写
# lower(): 将整个字符串改为小写
# upper(): 将整个字符串该为大写
help(str.title)
a = 'our domain in crazyit.org'
print(a.title()) # 每个单词的首字母大写
print(a.lower()) # 每个字母小写
print(a.upper()) # 每个字母大写
删除空白
# 删除空白
# strip(): 删除字符串前后空白
# lstrip(): 删除字符串前面(左边)的空白
# rstrip(): 删除字符串后面(右边)的空白
# 三个方法只是返回字符串前面或后面空白被删除之后的副本，并没有正在改变字符串本身
help(str.strip)
print('=' * 90)
s = ' this is a puppy '
print(s.strip()) # 删除字符串前后空白
print(s.lstrip()) # 删除字符串前面(左边)的空白
print(s.rstrip()) # 删除字符串后面(右边)的空白
print('=' * 90)
# 删除字符串前后指定字符
s2 = 'i think it is a scarecrow'
print(s2.lstrip('itow')) # 删除左边 i,t,o,w 字符
print(s2.rstrip('itow')) # 删除右边 i,t,o,w 字符
print(s2.strip('itow')) # 删除两边 i,t,o,w 字符
print('=' * 90)
查找 / 替换 相关方法
# 查找，替换相关方法
# startswith(): 判断字符串是否指定子串开头
# endswith(): 判断字符串是否以子串结尾
# find(): 查找指定子串在字符串中出现的位置，如果没有找到指定子串，返回-1
# index(): 查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发 ValueError 错误
# replace(): 使用指定子串替换字符串中的目标子串
# translate(): 使用指定的翻译映射表对字符串执行替换
s = 'crazyit.org is a good site'
print(s.startswith('crazyit')) # 是否以 crazyit 开头
print(s.endswith('site')) # 是否以 site 结尾
print(s.find('org')) # org 出现的位置
print(s.index('org')) # org 出现的位置(没有找到指定子串，则引发 ValueError 错误)
print(s.replace('it', 'xxxx')) # 所有的 it 替换成 xxxx
print(s.replace('it', 'xxxx', 1)) # 字符串中的 1 个 it 替换成 xxxx
print('=' * 90)
# 定义翻译映射表: 97(a) -> 945(a), 98(b) -> 946(B), 116(t) -> 964(T)
table = {97: 945, 98: 946, 116: 964}
print(s.translate(table))
print('=' * 90)
# python 为 str 类提供了 maketrans()方法，通过该方法可以非常方便地创建翻译映射表
# 程序只需要将需要映射的所有字符作为 maketrans()方法的第一个参数，
# 将所有映射的目标字符作为 maketrans() 方法的第二个参数即可
table = str.maketrans('abt', 'aBT')
print(table)
table = str.maketrans('abc', '123')
print(table)
print('=' * 90)
分割 / 连接方法
# 分割，连接方法
s = 'crazyit.org is a good site'
# split(): 将字符串按指定分割符分割成多个短语
print(s.split()) # 使用空白对字符串进行分割
print(s.split(None, 2)) # 使用空白对字符串进行分割，最多只分割前两单词
print(s.split('.')) # 使用 . 进行分割
print('=' * 90)
# join(): 将多个短语连接成字符串
mylist = s.split()
print('/'.join(mylist)) # 使用 '/' 将 mylist 连接成字符串
print(','.join(mylist)) # 使用 ',' 将 mylist 连接成字符串
运算符
赋值运算符
# 赋值运算符用于为变量或常量指定值
# python 使用 '=' 作为赋值运算符，通常使用赋值运算符将表达式的值赋值给另一个变量
st = 'python'
pi = 3.14
visited = True
# 赋值运算符将一个变量的值赋给另一个变量
st2 = st
# 连续赋值
a = b = c = 20
# 表达式的值赋值给变量
d1 = 12.34
d2 = d1 + 5
print('d2的值为:', d2)
算数运算符
# python 支持所有的基本算数运算符
# 算数运算符用于执行基本的数学运算， + , - , * , /
# +: 加法运算
a = 5.2
b = 3.1
the_sum = a + b # + 还可以作为字符串的连接运算符
print('the_sum 的值: ', the_sum)
print('=' * 90)
# -: 减法运算
c = 5.2
d = 3.1
sub = c - d
print('sub 的值: ', sub)
# 还可以作为求负的运算符
x = -5.0
x = -x
print('x 的值: ', x)
# 单目运算符 '+' 则不对操作数做任何改变
y = -5.0
y = +y
print('y 的值: ', y)
print('=' * 90)
# *: 乘法运算符
e = 5.2
f = 3.1
multiply = e * f
print('multiply 的值: ', multiply)
print('=' * 90)
# /或//: 除法运算符
# "/" 表示普通除法，使用它除出来的结果与平常数学计算的结果是相同的（即除不尽时，会产生小数部分）
# "//" 表示整除, 使用它除出来的结果只有整数部分
# python 不允许使用 0 作为除数，否则将会引发 ZeroDivisionError 错误
# （在有些变成语言中，0作为除数会得到无穷大，包括正无穷大或负无穷大）
print('19 / 4 的结果是:', 19 / 4)
print('19 // 4 的结果是', 19 // 4)
print('=' * 90)
# 对于 python2.x而言，它只提供了 '/' 运算符，该运算符是python3.x中 '/' 和 '//' 的综合版
# - 当两个操作数都是整数时， python2.x中的 '/' 就是整除运算
# - 当两个操作数有一个是浮点数（或两个都是浮点数时）， '/' 就是非整数运算符
# %: 求余运算符
print('5 % 3的值为: ', 5 % 3)
print('5.2 % 3.1 的值为: ', 5.2 % 3.1)
print('-5.2 % -3.1 的值为', -5.2 % -3.1)
print('5.2 % -2.9 的值为', 5.2 % -2.9)
print('5.2 % -1.5 的值为', 5.2 % -1.5)
print('-5.2 % 1.5 的值为', -5.2 % 1.5)
print('=' * 90)
# **: 乘方运算
print('5的2次方: ', 5 ** 2)
print('4的3次方: ', 4 ** 3)
print('4的开平方: ', 4 ** 0.5)
print('27 的开 3次方: ', 27 ** (1 / 3))
位运算符
# 位运算符
# 使用位运算符可以直接操作数值的原始 bit 位，尤其实在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码非常有效
# - & 按位与
# - | 按位或
# - ^ 按位异或
# - ~ 按位取反
# - << 左位移运算符
# - >> 右位移运算符
| 操作数1 | 操作数2 | 按位与 | 按位或 | 按位异或 |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
扩展后的赋值运算符
# +=: 对于 x += y, 对应 x = x + y
# -=: 对于 x -=y, 对应 x = x - y
# *=: 对于 x *=y, 对应 x = x * y
# /=: 对于 x /= y, 对应 x = x / y
# //=: 对于 x //= y, 对应 x = x // y
# %=: 对于 x %= y, 对应 x = x % y
# **=: 对于 x **= y, 对应 x = x ** y
# &=: 对于 x &= y, 对应 x = x & y
# |=: 对于 x |= y, 对应 x = x | y
# ^=: 对于 x ^= y, 对应 x = x ^ y
# <<=: 对于 x <<= y, 对应 x = x << y
# >>=: 对于 x >>= y, 对应 x = x >> y
# 只要能使用扩展后的运算符，通常都推荐使用这种赋值运算符
索引运算符
# 在使用索引范围时，还可指定步长
a = 'abcdefghijklnm'
print(a[2:8:3]) # 2开始 8结束 3步长
print(a[2:8:2]) # 2开始 8结束 2步长
比较运算符 与 bool 类型
# 比较运算符 与 bool 类型
# - bool 类型就是用于代表某个事情的真(对)True 或 假(错)Flase
# 比较运算符用于判断两个值(这两个值既可以是变量，也可以是常量，还可以是表达式)之间的大小，比较运算的结果是 bool(True真 / False假)
# - >: 大于
# - >=: 大于等于
# - <: 小于
# - <=: 小于等于
# - ==: 等于
# - !=: 不等于
# - is: 判断两个变量所引用的对象是否相同
# - is not: 判断两个变量所引用的对象是否不相同
print('5 是否大于 4', 5 > 4)
print('20 是否大于等于 20.0', 20 >= 20.0)
print('5 是否等于 5.0', 5 == 5.0)
print('True 和 False 是否相等', True == False)
print('=' * 120)
# 实际上 True 可以被当成整数 1 使用， False 也可以被当成整数 0使用
# True 和 False 两个值完全可以参与各种算数运算
print('1 和 True 是否相等', 1 == True)
print('0 和 False 是否相等', 0 == False)
print('True + False = ', True + False)
print('False - True = ', False - True)
print('=' * 120)
# == 与 is 看上去很相似，实际上有区别
# == 只比较两个变量的值
# is 要求两个变量引用同一个对象
import time
a = time.gmtime()
b = time.gmtime()
print(a == b)
print(a is b) # 不是同一个对象
# id() 函数，查看变量所引用的内存地址
print(id(a))
print(id(b))
逻辑运算符
# 逻辑运算符
# 用于操作 bool 类型的变量，常量或表达式，逻辑运算的返回值也是 bool 值
# and 与: 前后True, 返回 True，反之 False （一假则假）
# or 或: 两个操作数中有一个True， 就可以 True，否则返回 False （一真则真）
# not 非: 只需要一个操作数，如果操作数为 True，则返回 False; 如果操作数为 False，则返回 True（取反）
print('True and True: ', True and True)
print('True and False: ', True and False)
print('False and True: ', False and True)
print('False and False: ', False and False)
print('=' * 90)
print('True or True: ', True or True)
print('True or False: ', True or False)
print('False or True: ', False or True)
print('False or False: ', False or False)
print('=' * 90)
print('not True: ', not True)
print('not False: ', not False)
三目运算符
# 三木运算符
# python 可通过 if 语句来实现三木运算符的功能
# 可以近似地把这种 if 语句当成 三木运算符
# True statement if expression else False_statement
# 条件成立 if 比较运算 else 条件不成立
a = 5
b = 3
st = 'a 大于 b' if a > b else 'a 不大于 b'
print(st)
print('=' * 90)
in 运算符
# in运算符
# 用于判断某个成员是否位于序列中
# 程序可使用 in 运算符判断字符串是否包含特定字串
# in 的反义词 not in
s = 'crazyit.org'
print("'it' in s: ", 'it' in s)
print("'it' not in s: ", 'it' not in s)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
