第二章 Python基本概念
这一章节, 主要介绍Python的组成和命名规则, 变量和常量的声明, 基本数据类型和运算符详情等内容
.py
缩进
通常采用“四个空格”表示一个缩进. 并且避免将“tab制表符”或者tab与空格混合的缩进风格。 目前,常用的编辑器一般设置成:tab制表符就是4个空格
Python中,一切皆对象。 每个对象由: 标识(identity)、类型(type)、值(value) 组成
代码测试: 输出对象的类型, id, 值
a = 1
print(a) # 查看对象的值(value)
print(id(a)) # 查看对象id
print(type(a)) # 查看对象类型(type)
b = "我是谁"
print(b)
print(id(id(b)))
print(type(b))
运行结果
深入理解对象
内存示意图
标识符规则:用于变量、函数、类、模块等的名称。 规则如下:
__init__
是类的构造函数变量的声明和赋值:用于将一个变量绑定到一个对象上,格式: 变量 名 = 表达式 注意: 同Java一样, 变量在使用前必须先被初始化(先被赋值)!
最简单的表达式就是字面量. 比如: a = 3
变量赋值内存变化情况:
运行过程中,解释器先运行右边的表达式,生成一个代表表达式运算结果的对象;
然后,将这个对象地址赋值给左边的变量, 如下图所示:
如果直接调用未赋值的变量, 例如 print(a)
则会报如下错误:
Traceback (most recent call last):
File "C:\code\python_code\mypro01\mypy08-variable.py", line 6, in <module>
print(a)
NameError: name 'a' is not defined
如果对象没有变量引用,就会被垃圾回收器回收,清空内存空间. (这一过程是自动的) 也可以通过del语句删除不再使用的变量
删除变量操作:
a=123
del a
print(a)
Python不支持常量,因为没有语法规则限制改变一个常量的值 我们只能约定常量的命名规则,以及在程序的逻辑上不对常量的值作出修改
MAX_SPEED = 120
print(MAX_SPEED) # 输出120
MAX_SPEED = 140 # 实际是可以改的。只能逻辑上不做修改。
print(MAX_SPEED) # 输出140
链式赋值用于同一个对象赋值给多个变量。
x = y = 666
系列数据赋值给对应相同个数的变量(个数必须保持一致)
a, b = 1, 2 # 相当于 a=1, b=2
a, b = b, a # 变量值互换
print(a, b)
python中变量没有类型,但是对象都有类型
python中最基本的内置数据类型:
基本运算符说明:
基本运算符演示:
注意区分和Java不同的运算符:
/
: 浮点数除法,//
: 整数除法,**
: 幂
# 加法
print(1 + 1) # 2
# 减法
print(3 - 1) # 2
# 乘法
print(5 * 5) # 25
# 浮点数除法
print(7 / 2) # 3.5
# 整数除法
print(7 // 3) # 2
# 取模
print(7 % 3) # 1
# 幂
print(2 ** 4) # 16
# 使用 divmod() 函数同时得到商和余数
print(divmod(7, 3))
# print(3 / 0)
print(0 / 3)
1. Python中,除了十进制,还有其他三种进制:
测试代码
print("测试不同进制")
print(12) # 12
print(0b101) # 5
# print(0o19) # SyntaxError: invalid digit '9' in octal literal
print(0o10) # 8
print(0xff) # 255
2. 使用**int()
**实现类型转换:
print("使用int()实现类型转换:")
print(int(9.9))
print(int("456"))
print(int(True))
print(int(False))
print(bool(0))
print(bool(1))
3. 自动转型:整数和浮点数混合运算时,表达式结果自动转型成浮点数. 比如:2+8.0
的结果是 10.0
测试代码
print("字符串符合整数格式(浮点数格式不行)则直接转成对应整数,否则报错")
print(int("456"))
# print(int("456abc"))
# print(int("456.78"))
print("整数和浮点数混合运算时,表达式结果自动转型成浮点数")
print(2+6.8)
4. 整数可以任意大
测试代码
# 10的100次冪
googol = 10**100
print(googol)
Float
浮点数用科学计数法表示. 比如: 3.14 ,表示成: 314E-2 或者 314e-2 1 这些数字在内存中也是按照科学计数法存储
1. 类型转换和四舍五入
测试代码
print("浮点数用科学计数法表示, 这些数字在内存中也是按照科学计数法存储")
print(float(314E-2))
print(float(314e-2))
print(float("3.1415"))
print("整数和浮点数混合运算时,表达式结果自动转型成浮点数")
print(2+6.8)
print("round(value) 可以返回四舍五入的值. 但不会改变原有值, 而是产生新值")
print(round(4.51)) # 5
print(round(4.50)) # 4
print(round(4.55, 1)) # 4.5
2. 增强型赋值运算符
运算符
+ 、 - 、 * , / 、 // 、 **
和%
和赋值符=
结合可以构成“增强型赋值运算符”。
测试代码
x, y = 1, 2
y *= x + 2
print(y)
Python2中没有布尔值,直接用数字 0 表示 False , 用数字 1 表示True 。 Python3中,把 True 和 False 定义成了关键字,但他们的本质还是 1 和 0 ,甚至可以和数字相加。
在Python语言中有一些特殊的布尔类型值为False,例如:
False
、0
、0.0
、空值None
、空序列对象(空列表、空元祖、空集合、空字典、空字符串)、空range对象、空迭代对象.
其他情况,均为True
测试代码
a = True
b = 3
c = a + b # c的值是:4
print(c)
print('空字符串的布尔类型的值:', bool("")) # False
print('空列表布尔类型的值:', bool([])) # False
print('None布尔类型的值:', bool(None)) # False
print('0布尔类型的值:', bool(0)) # False
print('0.0布尔类型的值:', bool(0.0)) # False
print('字符串True和False转成布尔都是True:', bool("False")) # True
字符串是 Python 中最常用的数据类型。我们可以使用引号 (
'
或"
) 来创建字符串。
\n
: 换行 \r
: 回车 \t
:横向制表符 \b
:退格 \\
:输出转义符 \
+
*
input()
replace()
str()
substring()
上述介绍配套测试代码
# 1.字符串基本特点
# Python的字符串是不可变的,但可以将字符串的一部分复制到新创建的字符串,达到“看起来修改”的效果。
# 2.字符串的编码
# Python3直接支持Unicode,可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码,ASCII码是Unicode编码的子集。
# 使用内置函数ord()可以把字符转换成对应的Unicode码;
print(ord("A"))
print(ord("a"))
print(ord("明"))
# 使用内置函数chr()可以把十进制数字转换成对应的字符。
print(chr(706))
# 3.引号创建字符串
# 我们可以通过单引号或双引号创建字符串。 使用两种引号的好处是可以创建本身就包含引号的字符串,而不用使用转义字符。
a = "I'm a teacher!"
print(a) # I'm a teacher!
b = 'my_name is "TOM"'
print(b) # my_name is "TOM"
# 4.连续三个单引号或三个双引号,可以帮助我们创建多行字符串。在长字符串中会保留原始的格式。
c = '''Fake
news
!
'''
print(c)
# 5.空字符串和len()函数
# Python允许空字符串的存在,不包含任何字符且长度为0。
print(len('a'))
print(len(''))
# len()用于计算字符串含有多少字符。
print(len("天子守国门,君王死社稷"))
# 6.转义字符
# \n: 换行 \r: 回车 \t:横向制表符 \b:退格 \\:输出转义符
print("啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊\n惺惺惜惺惺嘻嘻嘻嘻嘻嘻嘻\r惺惺惜惺惺\t想新\b写写嘻嘻嘻惺惺惜惺惺想新写写许许多多的若若若热\\二二")
# 7.字符串拼接
# 可以使用 + 将多个字符串拼接起来
a = '皮尔斯' + '摩根'
print(a)
# 可以将多个字面字符串直接放到一起实现拼接。
b = '皮尔斯''摩根'
print(b)
# 8.字符串复制
# 使用*可以实现字符串复制
c = "MAGA!" * 3
print(c)
# 9.不换行打印
# 我们可以通过参数end = “任意字符串”。实现末尾添加任何内容:
print("唐纳德", end=' ')
print("特朗普", end='##')
print("特离谱")
# 10.从控制台读取字符串
# 我们可以使用input()从控制台读取键盘输入的内容。
# myCash = input("请输入付款金额""(若付款, 概不退换): ")
# print("您的收款金额是: " + myCash)
# 11.replace() 实现字符串替换
# 整个过程中,实际上我们是创建了新的字符串对象,并指向了变量a,而不是修改了以前的字符串。
a = "Mr Trump say: Fake news!"
a = a.replace("Trump", "Trace")
print(a)
# 12.str()实现数字转型字符串
a = str(5.20) # 结果是:a = ‘5.20’
b = str(3.14e2) # 结果是:b = ’314.0’
c = str(True) # 结果是:c = ‘True’
print(a)
print(b)
print(c)
"""
13.使用[]提取字符
字符串的本质就是字符序列,我们可以通过在字符串后面添加[], 在[]里面指定偏移量,可以提取该位置的单个字符。
正向搜索:
最左侧第一个字符,偏移量是0,第二个偏移量是1,以此类推。直到len(str)-1为止。
反向搜索:
最右侧第一个字符,偏移量是-1,倒数第二个偏移量是-2,以此类推,直到-len(str)为止
"""
a = "Ivanka Trump"
# 字符串开头
print(a[0])
print(a[-len(a)])
# 字符串结尾
print(a[-1])
print(a[len(a) - 1])
# 14.字符串切片slice操作
# 切片slice操作可以让我们快速的提取子字符串。标准格式为 起始偏移量start:终止偏移量end:步长step
# 典型操作(三个量为正数的情况)如下
a = "Donald Trump"
print("[:] 提取整个字符串: ", a[:])
print("[start:] 从start索引开始到结尾: ", a[2:])
print("[:end] 从头开始知道end-1: ", a[:2])
print("[start:end] 从start到end-1: ", a[2:4])
print("[start:end:step] 从start提取到end-1,步长是step: ", a[1:8:2])
# 其他操作(三个量为负数)的情况:
print("倒数三个:", a[-3:])
print("倒数第八个到倒数第三个(包头不包尾): ", a[-3:-1])
print("步长为负,从右到左反向提取: ", a[::-1])
# 切片操作时,起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围,也不会报错。起始偏移量小于0则会当做0,终止偏移量大于“长 度-1”会被当成-1。
print(a[7:100])
# 15. split()分割和join()合并
# split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符,则默认使用空白字符
a = "Mr Trump say: Fake news!"
print(a.split())
print(a.split(":"))
# join()的作用和split()作用刚好相反,用于将一系列子字符串连接起来。
b = ['Mr', 'Trump', 'say:', 'Fake', 'news!']
print('-'.join(b))
# 16. 字符串驻留机制和字符串比较
# 字符串驻留:常量字符串只保留一份
c = "dd#"
d = "dd#"
print(c is d) # True
# 17. 字符串比较和同一性
# 可以直接使用 == != 对字符串进行比较,是否含有相同的字符
# 使用 is not is ,判断两个对象是否同一个对象。比较的是对象的地址,即 id(obj1) 是否和 id(obj2) 相等。
a = "Donald Trump"
b = "Ivanka Trump"
print(a == b)
print(a is not b)
# 18. 成员操作符判断子字符串
# in not in 关键字,判断某个字符(子字符串)是否存在于字符串中。'
print("ab" in "abcdefg")
# 19. 字符串常用方法汇总
a = '''明太祖朱元璋,朱标,建文帝朱允炆
明成祖朱棣,明仁宗朱高炽,明宣宗朱瞻基,明英宗朱祁镇,明代宗朱祁玉
明宪宗朱见深,明孝宗朱佑樘,明武宗朱厚照,明睿宗朱祐杬,
明世宗朱厚熜,明穆宗朱载垕,明神宗朱翊钧,
明光宗朱常洛.明熹宗朱由校,明思宗朱由检
'''
print(len(a))
print(a.startswith("明太祖"))
print(a.endswith("朱由检"))
print("第一次出现指定字符串的位置: ", a.find("朱"))
print("最后一次出现指定字符串的位置", a.rfind("朱")) # 测试为false, 原因待定位
print("指定字符串出现了几次: ", a.count("宗"))
print("所有字符全是字母或数字: ", a.isalnum())
# 20. 去除首尾信息
# 我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息,rstrip()去除字符串右边指定信息。
print("-abc-".strip("-"))
print("-abc-".lstrip("-"))
print("-abc-".rstrip("-"))
# 21. 大小写转换
a = "Mr Trump say: Fake news!"
print("产生新的字符串,首字母大写: ", a.capitalize())
print("产生新的字符串,每个单词都首字母大写:", a.title())
print("产生新的字符串,所有字符全转成大写: ", a.upper())
print("产生新的字符串,所有字符全转成小写: ", a.lower())
print("产生新的,所有字母大小写转换: ", a.swapcase())
# 22. 格式排版
# center() 、 ljust() 、 rjust() 这三个函数用于对字符串实现排版。
a = "asd"
print(a.center(100, "*"))
print(a.center(100))
print(a.ljust(100, "*"))
print(a.rjust(100, "*"))
'''
23. 特征判断方法
isalnum() 是否为字母或数字
isalpha() 检测字符串是否只由字母组成(含汉字)
isdigit() 检测字符串是否只由数字组成
isspace()检测是否为空白符
isupper() 是否为大写字母
islower() 是否为小写字母
'''
a = "trump拆那"
print(a.isalnum())
print(a.isalpha())
print(a.isdigit())
print(a.isspace())
print(a.isupper())
print(a.islower())
print(a.isdecimal())
# 24. 字符串的格式化
# format() 基本用法基本语法是通过 {} 和 : 来代替以前的 % 。
# format() 函数可以接受不限个数的参数,位置可以不按顺序。
a = "今年是{0}年, 是农历十二生肖中的{1}年"
print(a.format(2022, "鼠"))
# 我们可以通过{索引}/{参数名},直接映射参数值,实现对字符串的格式化,非常方便。
b = "爸爸的爸爸叫什么? 爸爸的爸爸叫{grandpa}"
print(b.format(grandpa="爷爷"))
# 25. 填充与对齐
# 填充常跟对齐一起使用
# ^ 、 < 、 > 分别是居中、左对齐、右对齐,后面带宽度
# : 号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充
print("{:*>10}".format("testStr")) # 在十个字符中将字符串居右对齐, 多出的用*补齐
print("我是{0},{1:w^6}这里你把握不住".format("潘长江", "嘎子"))
# 26. 数字格式化
# 浮点数通过 f ,整数通过 d 进行需要的格式化。
a = "您的支付宝到账{:.2f}元, 需还款{:10d}元"
print(a.format(14138.552673, 6))
# 27. 可变字符串
# Python中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,只能创建新的字符串对象。
# 确实需要原地修改字符串,可以使用io.StringIO对象或array模块
import io
s = "hello, EVA"
sio = io.StringIO(s) # 可变字符串
print(sio)
v1 = sio.getvalue()
print("v1:", v1)
char7 = sio.seek(7) # 指针知道索引7这个位置
sio.write("OnePiece")
v2 = sio.getvalue()
print("v2:", v2)
# 类型转换总结
# 转换为int
print('int()默认情况下为:', int())
print('str字符型转换为int:', int('010'))
print('float浮点型转换为int:', int(234.23))
# #十进制数10,对应的2进制,8进制,10进制,16进制分别是:1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))
# 转换为float
print('float()默认情况下为:', float())
print('str字符型转换为float:',
float('123.01'))
print('int浮点型转换为float:', float(32))
# 转换为complex
print('创建一个复数(实部+虚部):', complex(12, 43))
print('创建一个复数(实部+虚部):', complex(12))
# 转换为str字符串
print('str()默认情况下为:', str())
print('float型转换为str:', str(232.33))
print('int转换为str:', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))
# 转换为list
strs = 'hongten'
print('序列strs转换为list:', list(strs))
# 转换为tuple(元组)
print('列表list转换为tuple:', tuple(lists))
# 字符和整数之间的转换
print('整数转换为字符chr:', chr(67))
print('字符chr转换为整数:', ord('C'))
print('整数转16进制数:', hex(12))
print('整数转8进制数:', oct(12))
计算机中时间的表示是从“1970年1月1日 00:00:00”开始,以毫秒(1/1000秒)进行计算 我们把1970年这个时刻称为“unix时间点
python中可以通过time.time() 获得当前时刻,返回的位,带微秒(1/1000毫秒)精度的浮点值. 例如下面测试代码:
import time
b = int(time.time()) # 返回从1970到今天的秒数
totalMinutes = b // 60 # // 整数除法
totalHours = totalMinutes // 60
totalDays = totalHours // 24
totalYears = totalDays // 365 # 忽略闰年情况
print(b)
print(totalMinutes)
print(totalHours)
print(totalDays)
print(totalYears)
逻辑运算符总结:
测试代码
a, b, c = 1, 2, 3
print((a < b) and (b < c))
print((a > b) or (a < b))
print(not (a < b))
所有比较运算符返回 1 表示真,返回 0 表示假. 这分别与特殊变量True 和 False 等价
测试代码
a = 5
if a <= 30:
print("a<30")
if 4 <= a <= 30:
print("1<=a<=10")
if 4 <= a & a <= 30:
print("4 <= a & a <= 30")
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如图所示:
测试代码
a = 0b11001
b = 0b01000
print(bin(a | b)) # bin()可以将数字转成二进制表示 '0b11001'
print(bin(a & b)) # 与
print(bin(a ^ b)) # 异或
print(3 << 2) # 左移1位相当于乘以2.左移两位相当于:3*(2*2)
print(20 >> 1) # 右移移位相当于除以2
加法操作补充
3+2
结果是 5
“3”+“2”
结果是 “32”
[10,20,30]+[5,10,100]
结果是 [10,20,30,5,10,100]
乘法操作补充
3*2
结果是 6
复合赋值可以让程序更加精炼,提高效率 与 C 和 JAVA 不一样, Python 不支持自增(**
++
**)和自减(**--
**)
测试代码
str_a = "Time"
str_b = "Pause"
str_c = "The"
str_d = "WorldWorld"
str_a += "e"
# str_b -= "e"
str_c *= 3
# str_d /= 2
print(str_a) # 加法支持字符串拼接
print(str_b) # 减法不支持字符串裁剪
print(str_c) # 乘法支持字符串拼接
print(str_d) # 除法也不支持字符串操作
a = 1 << 2
a <<= 2
print("1左移2位", 1 << 2, "a左移赋值", a)
注意:
增强赋值运算符左右需要空格, 但组成增强赋值运算符的运算符之间不需要空格
同一运算符用于比较两个对象的存储单元,实际比较的是对象的地址
is 与 == 区别:
__eq__()
方法。测试代码
a = 2
b = 2
c = 3
print("a和b是同一个对象", a is b) # 执行结果:True, is比较的是id, 即对象的引用地址/内存地址
print("a和c是同一个对象", a is c) # 执行结果False
print("a和c不是同一个对象", a is not c) # 执行结果True
总结
is
比较两个对象的 id 值是否相等,是否指向同一个内存地址==
比较的是两个对象的内容是否相等,值是否相等is
运算符比 ==
效率高,在变量和 None
进行比较时,应该使用 is
语言底层用数组实现,连续分配空间,便于查找
,而并非是所有整数对象成员运算符测试实例中包含了一系列的成员,包括字符串,列表或元组
测试代码
a = "python"
b = "py"
print(b in a) # True
c = [10, 20, 30]
print(10 not in c) # False
运算符优先级如下图,从高到低依次为:
测试代码
# 测试运算符优先级
a, b, c, d = 20, 10, 15, 5
e = (a + b) * c / d # 30*15/5
print('(a+b)*c/d的执行结果:', e)
e = (a + b) * (c / d) # 30*(15/5)
print('(a+b)*(c/d)的执行结果:', e)
e = a + (b * c) / d # 20+150/5
print('a+(b*c)/d的执行结果:', e)
注意:
基本运算符注意包括以下几类: