一、注释
1.1 注释的说明
对程序中某一块代码的解释,也可以是将代码中某一块暂不执行的代码注释掉,注释不影响程序的性能,它是不参与程序执行的。
1.2 单行注释和多行注释
注释有:单行注释和多行注释两种
- 单行注释:快捷键 ctrl + / ,代码格式为一个 # + 要解释说明的内容。
- 多行注释:使用三对单引号 ‘’’ ‘’’ 或者三对双引号包括的内容 “”" “”",常用来解释比较长的文本,一句话说明不了代码的功能时,可以考虑用多行注释。
# 单行注释说明print函数的作用
# 打印'Hello, world'
print('Hello, world')
# 多行注释说明打印的明信片内容
'''
打印明信片内容
姓名: 老夫子
QQ: 231312312
手机号: 15024193635
公司地址: 广州市白云区
'''
name = '老夫子'
QQ = '231312312'
手机号 = '15024193635'
addr = '广州市白云区'
print('姓名:%s'%name) # 姓名:老夫子
print('QQ:%s'%QQ) # QQ: 231312312
print('手机号:%S'%phone) # 手机号:15024193635
print('地址:%s'%addr) # 地址:广州市白云区
二、基本参数了解
2.1 变量
变量是用来存储数据的(它是数据的载体),它是用来保存和表示数据的占位符号。
2.2 命名规则
变量命名规则 | 用法 |
---|---|
变量名由数字、字母、下划线组成,且不能以数字开头。 | admin_、num_str、num1、List1 |
变量名区分大小写。 | num和 NUM不是同一个意思。 |
变量名不能是系统规定好的关键字。 | 参照链接。 |
变量名最好要见名知意。 | 比如求1~100的和,可以用total或者sum命名变量。 |
变量名可以由 大驼峰 和 小驼峰 命名法两种命名方法去定义。 |
-
大驼峰命名法:变量名从第一个单词开始,每个单词首字母要大写。Add_Number
-
小驼峰命名法:变量名从第二个单词开始,每个单词首字母大写。 numSum
2.3 变量的使用
变量在 单独创建时,必须要有初始值 ,否则会报错。
# 1.单独创建一个变量,需要定义,且有初始值。
num = 1
# 2.变量的重新赋值
# 说明:变量的重新赋值相当于后面的值将前面的值覆盖掉,一个变量在同一时刻只能存储一个数据
num = 66
print(num) # 66
num = 'abc'
print(num) # abc
# 3.定义多个变量
n1 = n2 = n3 = 100
print(n1,n2,n3) # 100 100 100
m1,m2,m3 = 34,6,7
print(m1,m2,m3) # 34 6 7
'''
总结:
1. 定义多个变量时,变量的数量和数据的数量需要保持一致。
'''
变量的 打包(pack) 和 拆包(unpack) 操作。
# a.打包
# 先分配俩单变量,分完后不定长参数接收剩余全部变量
x1,x2,*x3 = 34,6,7,56,7,78,8,9,0
print(x1,x2,x3) # 34 6 [7, 56, 7, 78, 8, 9, 0]
x1,*x2,x3 = 34,6,7,56,7,78,8,9,0
print(x1,x2,x3) # 34 [6, 7, 56, 7, 78, 8, 9] 0
*x1,x2,x3 = 34,6,7,56,7,78,8,9,0
print(x1,x2,x3) # [34, 6, 7, 56, 7, 78, 8] 9 0
# 注意:*只能使用一次
# x1,*x2,*x3 = 34,6,7,56,7,78,8,9,0
# SyntaxError: multiple starred expressions in assignment
# b.拆包
i,j,k = [4,6,7]
print(i,j,k) # 4 6 7
i,j,k = (4,6,7)
print(i,j,k) # 4 6 7
i,j,k = {4,6,7}
print(i,j,k) # 4 6 7
i,j,k = {"name":"张三","age":10,"salary":3000}
print(i,j,k) # name age salary
i,j,k = "NNB"
print(i,j,k) # N N B
"""
总结:
1. 打包的不定长参数只能有一个*,不能多个。
2. 拆包对应的参数数量要和原变量个数一致,多了少了都会报错。
3. 打包和拆包适用于字符串、列表、元组、字典和集合。
"""
定义变量和删除变量的区别
"""
定义变量:从无到有的过程,在计算机的内存中开辟一份空间,该空间中存储指定的数据
删除变量:从有到无的过程,计算机中的对应的内存空间会被释放掉
"""
# 1.定义变量
name = 'jack'
print(name)
# 2.删除变量
# 语法:del 变量名
del name
# 注意:一个变量一旦被删除,则相当于该变量未被定义
# print(name) # NameError: name 'name' is not defined
# print(num) # NameError: name 'num' is not defined
变量能保存任意类型数据、常见的数据类型有:
数据类型 | |
---|---|
整型(int,3) | 元组(tuple,(1,2,3,4)) |
浮点型(float,3.0) | 集合(set,{1,2,3,4}) |
字符串(str,‘abcde’) | 字典(dict,{‘name’:‘张三’,‘age’:20}) |
布尔值(bool,True、False) | 空值(NoneType,None)等 |
列表(list、[1,2,3,4]) | 二进制字节型bytes、(b’Hello’) |
变量交换的面试题
交换两个数的值:一共有4种方法
- 引入中间变量
- 变量直接互换
- 基本运算符互换
- 异或符号的使用
# a. 引入中间变量temp
a = 45
b = 66
temp = a
a = b
b = temp
print(a,b) # 66 45
# b. 变量直接互换
a = 45
b = 66
a,b = b,a # 底层工作原理就是方式一
print(a,b) # 66 45
# c. 算术运算符互换
a = 45
b = 66
a = a + b # a = 45 + 66
b = a - b # b = 45 + 66 - 66
a = a - b # a = 45 + 66 - 45
print(a,b) # 66 45
# d. 异或符号的使用
# 异或:^
# 规律:一个数异或另一个数两次,结果是该数本身
# print(7 ^ 3 ^ 3) # 7
# print(7 ^ 3 ^ 7) # 3
a = 45
b = 66
a = a ^ b # a = 45 ^ 66
b = a ^ b # b = 45 ^ 66 ^ 66
a = a ^ b # a = 45 ^ 66 ^ 45
print(a,b) # 66 45
2.4 常量
既然有变量,那么就会必不可免的会有常量。
常量在python中通常写法是:字母全大写,不同单词之间使用下划线进行连接。
# 注意:在程序中,如果一个变量表示的值无需修改,是一个固定量,则将该变量定义为常量
PI = 3.1415
print(PI) # 3,1415
# PI = 'ey46u'
# print(PI)
2.5 标识符(面试题)
概念:计算机编程语言中,标识符是用户编程时使用的名字,用于给变量、常量、函数、语句块等命名,以建立起名称与使用之间的关系
- 合法标识符的命名规则:
- 只能由数字,字母和下划线组成
- 不可以是除了下划线之外的其他特殊字符
- 开头不能是数字或者空格
- 不能是Python的关键字
- 严格区分大小写:age和Age表示两个不同的变量
- 标识符的命名规范:
- 尽量做到见名知意【具有描述性】:尽量使用简单的英文单词表示
- 遵守一定的命名规范
- Python官方推荐的命名方式:变量名,函数名和文件名全小写,使用下划线连接,如:stu_name check_qq
- 驼峰命名法:不同的单词之间使用首字母大写的方式进行分隔,又分为大驼峰和小驼峰,比如:stuName就是小驼峰,StuName就是大驼峰,小驼峰常用于变量或者函数的命名,大驼峰常用于类的命名
2.6 关键字(保留字)
概念: 一些具有特殊功能的标识符
注意:关键字已经被python官方使用了,所以不允许开发者自己定义和关键字重名的标识符,python中一共有33个保留字,查看保留字可以使用下面这样一串代码:
from keyword import kwlist
print(kwlist)
那么关键字具体有哪一些呢?
注意:
- True 和 False 是 bool 类型的两个值。
- None 是 NoneType (空)类型的值。
三、输入与输出函数
3.1 输入函数input
input函数是python库中一个内置的函数,它可以和程序进行交互,重要的是它可以和 eval 评估函数一起搭配使用。它的语法是:
变量 = input(<提示信息字符串>)
# 用户输入的信息以字符串类型保存在<变量>中
b = input(13)
print(type(b),b) # <class 'str'> 13
并且不论输入的是什么形式的内容,输出的数据类型永远是字符串。
3.2 输出函数print
print函数可以打印任何数据:
num = 1
print(num, 12, 45, 'abcde', True, False,[1,2,3,4,5],(1,2,3),{'name':'zhangqin','age':20})
print函数可以修改打印样式:
这里要介绍到两个字符:
sep - 分隔字符串,默认为空格。
end - 结束字符串,默认为换行符\n。
# sep参数默认值为空格
print(1, 2, 3, 4, 5, 6, 1 + 2) # 1 2 3 4 5 6 3
print(1, 2, 3, 4, 5, sep='😁') # 1😁2😁3😁4😁5
# end参数默认值为换行\n
print(1, end='\n') # 1
print(2, end='-') # 2-3
print(3)
格式化字符串输出的三种方式:
- 占位符式字符串匹配
- { }.format 匹配
- f '{ } ’ 格式化字面值匹配
格式化字符串的应用:
# 1.旧式的格式化字符串:%s、%d、%f,也称占位符号。
"""
%d:可以匹配数字,一般用来匹配整型
%f:可以匹配数字,一般用来匹配浮点型
%s:可以匹配任意类型
总结:
values如果只传入一个只,直接写到%后即可;如果传入多个值,使用小括号括起来。
"""
name = '尼古拉斯.赵四'
age = 18
hobby = '跳舞'
# 注意1:占位符和实际的数据的数量保持一致
print("姓名:%s,年龄:%d,爱好:%s" % (name,age,hobby))
# 注意2:实际的数据和占位符的类型需要匹配
# print("姓名:%s,年龄:%d,爱好:%s" % (name,hobby,age)) # TypeError: %d format: a number is required, not str
# 注意3:
# %.nf,n>=1,保留小数点后n位,n可以省略,会执行四舍五入操作,%f默认保留6位小数。
weight = 172.53965783
print("姓名:%s,年龄:%s,爱好:%s,身高:%f" % (name,age,hobby,weight))
print("姓名:%s,年龄:%d,爱好:%s,身高:%.f" % (name,age,hobby,weight))
# 需求:将身高保留小数点后两位
print("姓名:%s,年龄:%d,爱好:%s,身高:%.2f" % (name,age,hobby,weight))
# 打印结果为:
姓名:尼古拉斯.赵四,年龄:18,爱好:跳舞,身高:172.539658
姓名:尼古拉斯.赵四,年龄:18,爱好:跳舞,身高:173
姓名:尼古拉斯.赵四,年龄:18,爱好:跳舞,身高:172.54
# 注意4:
# %nd,n>=1,表示将一个整数显示成n位,不够则用空格补充
# %.nd,n>=1,表示将一个整数显示成n位,不够则用0补充
print("学号:%5d" % (1)) # 学号: 1
print("学号:%5d" % (30)) # 学号: 30
print("学号:%5d" % (125)) # 学号: 125
print("学号:%.5d" % (1)) # 学号:00001
print("学号:%.5d" % (30)) # 学号:00030
print("学号:%.5d" % (125)) # 学号:00125
# 2.format的用法
name = '张三'
edu = '清华大学'
str3 = '{}今年考入了{}'.format(name, edu)
print(str3) # 张三今年考入了清华大学
'''
format不但能格式化整体字符串,还可以单独格式化传入的内容
a. >、<、^ --> 右对齐、左对齐、居中对齐
b. : --> 左边为空,默认对传入值进行操作
c. >3 --> 传入值的长度小于3,右对齐,使用空格补全。
0>3 -> 传入值的长度小于3,右对齐,使用0补全。
'''
id = 20
stu_id = 'python{:0>3}'.format(id)
print(stu_id) # python020
# % - 将传入的值转换成百分数,自动进行四舍五入。
num = 0.124356789
str4 = '{:.2%}'.format(num)
print(str4) # 12.44%
# , - 千分位符
str5 = '我有{:,}元'.format(100000000)
print(str5) # 我有100,000,000元
# 3.格式化字符串字面值(f-字符串)
# 在字符串前面添加一个f或者F,字符串中变的位置使用{},{}中直接放变量。
# 简单来说,它就是.format的简化写法,性质基本类似。
name = '张三'
edu = '清华大学'
str3 = f'{name}今年考入了{edu}'
print(str3) # 张三今年考入了清华大学
课后练习:
- 编写一个程序,可以实现:提示用户输入用户名和密码,可以将数据以格式: 用户名:xxx,密码:xxx的形式打印出来的功能?
四、运算符
4.1 算术运算符
算术运算符 | 说明 |
---|---|
+ | 加法运算 |
- | 减法运算 |
* | 乘法运算 |
/ | 除法运算的结果永远为浮点数 |
// | 整除取整数 |
% | 整除取余数 |
** | 幂运算,求平方和开方 |
算术运算符的使用
# 1. +和-
m = 10
n = 5
print(m + n) # 15
print(m - n) # 5
print(5 - 3) # 2
print(5.0 - 3) # 2.0
print(5 - 3.0) # 2.0
print(5.0 - 3.0) # 2.0
# 只要有浮点数参与运算,那么结果就会是浮点数
# 2. /和//
# 除法运算符:计算结果永远是浮点数
print(6 / 3) # 2.0
# 整除:在除法运算的基础上向小取整,结果永远为整型。
print(9 // 4) # 2
# 3. %求余数
# 取余:余数不可能小于零
print(10 / 3, 10 // 3, 10 % 3)
print( -10 / 3, -10 // 3, -10 % 3)
# 打印结果分别为:
3.3333333333333335 3 1
-3.3333333333333335 -4 2
# 4. * 和 ** 运算
# 幂运算:如果使用幂运算做开方,结果永远为浮点数。
print(2 * 2, 4 ** 0.1, 4 ** 0.5)
# 打印结果为: 4 1.148698354997035 2.0
# 5. 优先级问题
print(2 + 3 * 5) # 17
print(2 * 3 * 5) # 30
print(2 * 5 ** 3) # 250
4.2 比较运算符
运算符 | 说明 |
---|---|
== | 相等 |
!= | 不相等 |
> | 大于 |
< | 小于 |
>= | 大于等于 |
<= | 小于等于 |
# 一.比较运算符的基本使用
# a.比较数据
a = 45
b = 10
print(a == b) # False
print(a != b) # True
print(a > b) # True
print(a >= b) # True
print(a < b) # False
print(a <= b) # False
# b.和其他运算符进行混合运算
print(a + 3 > b + 1) # True
# c. =和== 的区别
# =表示赋值,==表示比较【比较两个数据是否相等】
# 将10赋值给num,最终的结果是num中存储的是10
num = 10
print(num) # 10
# 比较num和10是否相等,整体会得到一个结果
r = num == 10
print(r) # True
# 二、常用的类型
# 1.数字
# 2.字符串
# 注意:如果字符串中的数据是数字,字母或常用符号,则比较大小底层参考的是ASCII码
"""
常见ASCII码的大小规则:数字< 大写字母 < 小写字母。
1.数字比字母要小。如 “7”<“F”;
2.同个字母的大写字母比小写字母要小32。如“A”<“a” 。
3.几个常见字母的ASCII码大小及范围: “A~Z”为65-90;“a~z”为97-122;“0~9”为48-57
"""
print('3' > 'x') # False
print("d" < 'D') # False
# 字符串比较的规则:相同位置的字符进行依次比较,直到遇到不相同的字符,则得出结果
print('abcdef' < 'hello') # True
print('abcdef' < 'abxgag') # True
总结:
关系运算符又称条件运算符,也被叫做比较运算符。
= 表示赋值,== 表示相等,注意两者的区别。
关系运算符运算的结果是一个布尔值,表达式成立则结果为True,如果表达式不成立则结果为False。
关系运算符常使用在判断语句if 和 循环语句while中。
课后小练习:
- 任意赋值两个变量 y,z,最后将值赋给变量x,试比较 x = ( y = z + 1) 和 x = ( y == z + 1) 两者输出结果的区别?
- 打印 x = 5 == 5 的结果,理解运算符的运算优先级!
4.3 逻辑运算符
逻辑运算符是用来做逻辑计算的,就像之前用到的比较运算符 ,每一次比较其实就是一次条件判断,都会得到一个相应的True或者False的值,而逻辑运算符的操作数就是一个用来做条件判断的表达式或者变量。
运算符 | 说明 |
---|---|
and | 与 |
or | 或 |
not | 非 |
逻辑运算符的应用
# 1.与:and
"""
真 and 真 ---》真
真 and 假 ---》假
假 and 真 ---》假
假 and 假 ---》假
规律:一假为假,全真为真
"""
print(True and 0) # 0
print('abc' and 0) # 0
print([3,5,5] and 0) # 0
print({'a':10} and 0) # 0
print(True and 45) # 45
print('abc' and 45) # 45
print([3,5,5] and 45) # 45
print({'a':10} and 45) # 45
print("*" * 50)
print(0 and True) # 0
print(0 and 'fafgv') # 0
print(0 and 466) # 0
print(0 and [34,6,7]) # 0
print(0 and 0.0) # 0
print(0 and []) # 0
print(0 and {}) # 0
print(0 and False) # 0
"""
结论:
A and B
a. 如果A为真,则整个表达式A and B的结果为B
b. 如果A为假,则整个表达式A and B的结果为A,B会被短路
c. and和or运算的结果不一定是布尔值,取决于参与运算的数据类型,not运算的结果一定是布尔值
"""
# 2.或:or
"""
真 or 真 ---》真
真 or 假 ---》真
假 or 真 ---》真
假 or 假 ---》假
规律:一真为真,全假为假
"""
print(True or 0) # True
print('abc' or 0) # abc
print([3,5,5] or 0) # [3,5,5]
print({'a':10} or 0) # {'a':10}
print(True or 45) # True
print('abc' or 45) # abc
print([3,5,5] or 45) # [3,5,5]
print({'a':10} or 45) # {'a':10}
print("*" * 50)
print(0 or True) # True
print(0 or 'fafgv') # fafgv
print(0 or 466) # 466
print(0 or [34,6,7]) # [34,6,7]
print(0 or 0.0) # 0.0
print(0 or []) # []
print(0 or {}) # {}
print(0 or False) # False
"""
结论:
A or B
a.如果A为真,则整个表达式A or B的结果为A,B会被短路
b.如果A为假,则整个表达式A or B的结果为B
"""
# 3.非:not
"""
not 真 ----》False
not 假----》True
"""
print(not 56) # False
print(not 0.0) # True
print(not 'abc') # False
print(not '') # True
短路原则:
A and B,如果A为False,不需要计算B的值,整个表达式的结果为False
A or B,如果A为True,不需要计算B的值,整个表达式的结果为True
and和or混合使用
- 表达式从左往右运算,如果 or 的左侧为 True,则会短路or后面所有的表达式【不管是and还是or连接】,整个表达式的结果为True
- 表达式从左往右运算,如果and的左侧为 False,则短路后面所有的 and,直到 or出现,接着计算
- 如果 or 的左侧为 False,或者 and 的左侧为 True,则不能使用短路逻辑判断
注意:所有被短路的表达式均不会被输出。
课后练习:
- 从控制台输入一个整数,判断是否大于3小于10?
- 从控制台输入一个整数,判断是否大于3小于1,试比较两者的区别?
4.4 赋值运算符
赋值运算符 | 说明 |
---|---|
= | 变量赋值,注意跟==的区别 |
+= | 加法运算等于,a = a + b |
-= | 减法运算等于,a = a - b |
*= | 乘法运算等于,a = a * b |
/= | 除法运算等于,a = a / b |
//= | 整除法运算等于,a = a // b |
%= | 取余运算等于,a = a % b |
**= | 求幂运算等于,a = a ** b |
赋值运算符的应用
num = 0
num += 2
num *= 3
num -= 1
num /= 2
print(num) # 2.5
num = 10
num %= 4
num //= 2
num **= 2
print(num) # 1
4.5 成员运算符
成员运算符使用两种表示形式:
in: 如果在指定的序列中找到值,则返回True,否则返回False
not in: 如果在指定的序列中没有找到值,则返回True,否则返回False
# 语法:数据 in/not in 容器
print('a' in 'abc') # True
print(10 in [45,6,78,8]) # False
print('a' not in 'abc') # False
print(10 not in [45,6,78,8]) # True
4.6 身份运算符
身份运算符用于比较两个对象的存储单元:
is: 判断两个标识符是不是引用自一个对象
is not: 判断两个标识符是不是引用自不同对象
# 判断两个对象的存储地址又分可变的数据类型和不可变的数据类型
# a.不可变数据类型: int、float、bool、str、tuple。
a = 10
b = 10
print(id(10),id(a),id(b))
# 比较两个变量的地址是否相同
print(a is b) # True
# 比较两个变量的值是否相等
print(a == b) # True
b = 20
print(id(10),id(20),id(a),id(b))
print(a is b) # False
print(a == b) # False
# b.可变的数据类型:list、dict、set。
list1 = [1,2,3]
list2 = [1,2,3]
print(id([1,2,3]),id(list1),id(list2))
print(list1 is list2) # False
print(list1 == list2) # True
总结:
- 两个变量的地址相同,则这两个变量的值一定相同。
- 两个变量的值相同,则这两个变量的地址不一定相同。
4.7 位运算符
运算符 | 说明 |
---|---|
& | 与 |
| | 或 |
^ | 异或 |
~ | 取反 |
<< | 左移 |
>> | 右移 |
位运算符的应用
# 1、位与运算符&的使用
print(6 & 3) # 2
print(8 & 3) # 0
"""
运算需要写出二进制字符串。
6: 0000 0110
&
3: 0000 0011
结果0000 0010
-------------------->
8: 0000 1000
&
3: 0000 0010
结果0000 0000
总结:
1. 全为1 则为 1。
"""
print("*" * 100)
# 2、位或运算符|的使用
print(6 | 3) # 7
print(8 | 3) # 10
"""
运算需要写出二进制字符串。
6: 0000 0110
|
3: 0000 0011
结果0000 0111
-------------------->
8: 0000 1000
|
3: 0000 0010
结果0000 1010
总结:
1. 只要有一个为1 就为 1。
"""
print("*" * 100)
# 3、异或运算符^的使用
# 交换两个变量的值
# 方式四:异或
a = 10
b = 20
a = a ^ b # a = 10 ^ 20
b = a ^ b # b = 10 ^ 20 ^ 20 = 10
a = a ^ b # a = 10 ^ 20 ^ 10 = 20
print(a,b) # 20 10
print(6 ^ 3) # 5
print(6 ^ 3 ^ 3) # 6
"""
异或的计算规律:
1. 相同为假,不同为真。
2. 一个变量异或另一个变量两次,得到的结果是它本身。
6: 0000 0110
3: 0000 0011
---------
0000 0101 ==> 5
0000 0011
---------
0000 0110 ==> 6
"""
# 取反
print(~6) # -7
"""
6: 0000 0110
~6: 1111 1001(补码)-->(补码-1)--> 1111 1000(反码)--> 1000 0111(原码-7)
"""
# 5、左移与右移
# a.左移
print(6 << 2) # 24
print(8 << 3) # 64
"""
6: 0000 0110
-------------
<< 0001 1000 ==> 6 * 2 ** 2 == 24
8: 0000 1000
-------------
<< 0100 0000 ==> 8 * 2 ** 3 == 64
总结:
1. 向左移位,后边用0补齐
2. m << n = m * 2 ** n。
"""
# b.右移
print(8 >> 3) # 1
print(-6 >> 3) # -1
"""
8: 0000 1000
------------
>> 0000 0001
-6 原码1000 0110
反码1111 1001
补码1111 1010
------------
1111 1111(补码) --> 1111 1110(反码) --> 1000 0001(原码-1)
>>
总结:
1. 向右移位,如果高位为1,则左边补1。
2. 向右移位,如果高位为0,则左边补0。
3. 负数在计算机中的存储形式为补码。
"""
总结:
- 位运算符和计算机的二进制数紧密相连,每次运算需要先写出对应数值的二进制数。
- 位运算的运算亦是对二进制数 0 和 1进行操作。
注意:进制转换,进制的表示形式,源码反码补码等扩展知识放在了文章末尾。
4.8 运算符优先级
- 算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符。
- ** > * 、/ 、 // 、 % > +、-
- 有小括号,先算小括号里边的。
4.9 请简述is 和 == 的区别?(面试题)
- is 比较的是两个对象的id值是否相等,也就是比较俩对象是否为同一个实例对象,是否指向同一个内存地址。它比较的是两个变量的地址。
- == 比较的是两个两个对象的内容或者是值是否相等,它比较的是两个变量的值。
五、基本数据类型和内置函数
5.1 python的内置数据类型一共有10种:
int、float、str、list、set、tuple、dict、NoneType、bool、bytes。
首先我们要先了解构造器语法:
- int( ) :将其它数据类型转换成 整型 数据。
- float( ):将其它数据类型转换成 浮点型 数据。
- str( ):将其它数据类型转换成 字符串 数据。
- list( ):将其它数据类型转换成 列表 数据。
- set( ):将其它数据类型转换成 集合 型数据。
- tuple( ):将其它数据类型转换成 元组 型数据。
- dict( ):将其它数据类型转换成 字典 类型。
5.2 什么样的数据能转整型(int)?
浮点数可以直接转整型。
布尔值可以转整型。 True == 1, False == 0。
去掉引号是一个整数的字符串可以转整型。
print(int(1.1), int(1.9)) # 1 1
print(int(True), int(False)) # 1 0
print(int('1')) # 1
5.3 什么样的数据可以转浮点型?
整型能够转浮点型。
布尔值可以转浮点型。
去掉引号是数字的字符串可以转浮点型。
print(float(1), float(0)) # 1.0 0.0
print(float('1')) # 1.0
print(float('1.0')) # 1.0
print(float('1.')) # 1.0
print(float('.1')) # 0.1
5.4 什么样的数据能够转成布尔值?
0 、0.0、None、’ '、[ ]、( )、{ }、set()能转为False。
除此之外的所有数据均为True。
bool 类型只有两个值:True 和 False。
print(bool('')) # False
print(bool([])) # False
print(bool({})) # False
print(bool(0)) # False
print(bool(0.0)) # False
print(bool(None)) # False
print(bool(set())) # False
print("*" * 100)
print(int(bool(10))) # 1
print(bool([1,3,4])) # True
print(bool((1,2,3))) # True
print(bool({1,2,3})) # True
print(bool({'a':10})) # True
print(bool("student")) # True
5.5 eval() 评估函数
eval ( ) 简称评估函数:
- 可以将字符串内部数据转换成它原本自带的数据类型,然后再做运算,也就是去掉参数最外侧引号并执行余下语句的函数。
# eval() - 计算一个有效的表达式
str2 = '1'
str3 = '1.1'
print(type(eval(str2))) # <class 'int'>
print(type(eval(str3))) # <class 'float'>
print(eval('1+2')) # 3
5.6 从温度转换实例来分析eval 评估函数的用法
在中国规定以1为标准大气压下0°C为水的结冰点温度,100°C为水的沸点。在其它欧美国家则是使用华氏度,水的结冰点温度为32℉,沸点为212℉。
那么就可以得到他们之间的转换公式:
- C = (F - 32) / 1.8
- F = C * 1.8 + 32
# 温度转换
TemStr = input("请输入温度值:")
if TemStr[-1] in ['F','f']:
C = (eval(TemStr[0:-1]) - 32)/ 1.8
print("转换后的温度为{:.2f}C".format(C))
elif TemStr[-1] in ['C','c']:
F = 1.8 * eval(TemStr[0:-1]) + 32
print("转换后的温度为{:.2f}F".format(F))
else:
print("输入格式错误")
eval函数就是将字符串的引号去掉,将输入的值输出为它原本的数据类型,然后再做运算。
换个思路,是不是可以举一反三呢,试着将符号放在温度前边,形如:C99, F108。重新再去编写这一段程序,理解这样一段程序后,可以解决大多数字符串问题。
5.7 id() 内置函数
id 函数获取的是变量在内存空间中的地址。
# 注意:每个数据在内存中的地址是独一无二的,定义变量之后,变量中实际上存储的是数据的地址
print(id('abc'))
s = 'abc'
print(id(s)) # 2143994634864
print(s) # 2143994634864
# 问题
print(id('jack'))
name1 = 'jack'
name2 = 'jack'
print(id(name1) == id(name2)) # True
5.8 type() 内置函数
type 函数是用来获取变量x的数据类型
a = '10'
b = 10
print(type(a)) # <class 'str'>
print(type(b)) # <class 'int'>
5.9 round() 内置函数
round 函数使用保留运算结果小数保留的位数的函数。
语法为:round(结果变量值,n) -->其中n表示保留小数的位数。
a = 12.345123
b = 3.21
print(round(a+b,1)) # 15.6
5.10 二进制字节型数据类型bytes
bytes:二进制字节型数据类型
编码和解码
- 编码:str=>bytes
- 解码:bytes=>str
# 二进制字节类型
a = b"Hello"
print(a,type(a)) # b'hello' <class 'bytes'>
# 编码 str=>bytes
s = "hello"
b = s.encode()
print(b, type(b)) # b'hello' <class 'bytes'>
# 解码 bytes=>str
s2 = b.decode()
print(s2,type(s2)) # hello <class 'str'>
六、计算机基础扩展
6.1 计算机进制转换
计算机在内存中是以二进制【0和1】的形式存储数据的,除了二进制,计算机还支持八进制和十六进制。一个二进制数表示一个比特(bit),也称为位,**计算机处理数据的最小单位为字节【Byte】,1Byte = 8bit。**比如:0010 1010。但是,我们生活中习惯使用十进制,所以当人与计算机之间进行交互的时候就要涉及到进制之间的转换。进制的表示有特定的符号集和进位制:
二进制:0和1,逢二进一
八进制:0~7
十进制:0~9,逢十进一
十六进制:0~9,超过9的用 a-f 和 A-F 表示。
计算机的单位表示:
单位:B,KB,MB,GB,TB,PB,EB…DB
换算关系:1KB = 1024B
6.2 计算机进制转换的原理
- 十进制转二进制
- 转换原理:对十进制数进行除2运算,直到商为0为止,然后将各个步骤得到的余数倒着写出来
例如:将十进制的10转换为二进制是?
10 // 2 -->5 余数:0
5 // 2 --> 2 余数:1
2 // 2 --> 1 余数:0
1 // 2 --> 0 余数:1
# 1010 --> 0000 1010
- 二进制转十进制
- 转换原理:把二进制数按权展开、相加即得十进制数(位权,十进制的位权是10,二进制的是2。
例如:
0000 1010----》1 x 2 ** 3 + 1 x 2 ** 1 = 10
0010 1010----》1 x 2 ** 5 + 1 x 2 ** 3 + 1 x 2 ** 1 = 42
1001 0110-----》1 x 2 ** 7 + 1 x 2 ** 5 + 1 x 2 ** 2 + 1 x 2 ** 1 = 150
- 二进制转八进制
- 转换原理:三位二进制按权展开相加得到1位八进制数,从右向左开始分组,三位为一组,不足时补0。
比如:1001 0110和1010001转换成八进制数是?
1001 0110---->010 010 110---->2 2 6--->226
# 226
1010001---->001 010 001---->1 2 1
# 121
- 二进制转十六进制
- 转换原理:与二进制转八进制方法相似,八进制是取三合一,十六进制是取四合一,同样,二进制转成十六进制是从右向左开始分组,四位为一组,不足时补0。
例如:
1001 0110---->9 6
# 96
1010001--->0101 0001---->5 1
# 51
1011 1110--->11 14--->b e
# be
0011 1011---->3 11 --->3b
# 3b
-
十进制—》八进制或者十六进制
-
方法一:把十进制转成二进制x,然后再由二进制转成八进制或者十六进制
-
方法二:对十进制除以8或者16进行取余,直到商为0为止,类似十进制转二进制
-
-
八进制或者十六进制—》十进制
- 转换原理:把八进制或者十六进制按权展开,相加即得十进制
6.3 原码反码补码
原码:一个数的二进制表示形式,高位表示符号位,0表示正数,1表示负数
反码:在原码的基础上,除了符号位之外,其他位取反
补码:在反码的基础上,加1
注意:正数的原码反码补码是同一个,如:6的二进制为0000 0110,则6的原码反码补码都是0000 0110
10 + (-10) = ?
10:原反补0000 1010
-10:原:1000 1010 反:1111 0101 补:1111 0110
1. 验证计算机里边存储的是源码、反码还是补码?
原码:
0000 1010
1000 1010
---------
1001 0100
反码:
0000 1010
1111 0101
---------
1111 1111
补码:
0000 1010
1111 0110
----------
0000 0000
结论:
计算机中存储数据采用的二进制的补码形式,人容易识别都是原码,计算机识别的是补码。
例题:模拟计算机计算 2 + (-4) =
2: 0000 0010
-4: 源码1000 0100
反码1111 1011
补码1111 1100
补码: 0000 0010
1111 1100
----------
1111 1110(补码) --> 1111 1101(反码) --> 1000 0010(源码)--> -2
6.4 进制的Python代码形式
# 二进制,八进制,十进制和十六进制在Python中都可以表示
# 1.二进制
# 表示方式:用0b开头,b:bin
n1 = 0b1010
print(n1) # 10
# 2.八进制
# 表示方式:用0o表示,o:oct
n2 = 0o226
print(n2) # 150
# 3.十进制
n3 = 43
print(n3) # 43
# 4.十六进制
# 表示方式:用0x表示,x:hex
n4 = 0x3b
print(n4) # 59
n41 = 0xef
print(n41) # 239
6.5 Python内置函数实现进制转换
函数 | 说明 |
---|---|
bin(x) | 将数字x转换为二进制 |
oct(x) | 将数字x转换为八进制 |
hex(x) | 将数字 x转换为十六进制 |
# 一、bin,oct,hex:将十进制转换为对应的二进制,八进制和十六进制
a = 10
x1 = bin(a)
print(x1) # 0b1010
x2 = oct(a)
print(x2) # 0o12
x3 = hex(a)
print(x3) # 0xa
# 二、int(value,base),base表示进制,也可以将二进制,八进制或者十六进制转换为十进制
print(int("234")) # 234
print(int("234",base=10)) # 234
print(int("234",10)) # 234
print(int("110",base=10)) # 110
print(int("110",base=2)) # 6 ==> 1 x 2 ** 2 + 1 x 2 ** 1 + 0 x 2 ** 0 == 6
print(int("110",base=8)) # 72 ==> 1 x 8 ** 2 + 1 x 8 ** 1 + 0 x 8 ** 0 == 72
print(int("110",base=16)) # 272 ==> 1 x 16 ** 2 + 1 x 16 ** 1 + 0 x 16 ** 0 == 272
print("*" * 66)
#练习题【面试题】
print(int("0b110220",base=16)) # 185664032
"""
先将16进制数全部展开,然后按2的位权相加。
0000 1011 0001 0001 0000 0010 0010 0000
按 2的位权展开,结果相加就是最终的结果。
"""
# 注意:
# 1. 如果在int中要使用base关键字,则value一般为字符串。
写在文章片尾的话:
- 该文章反反复复修改很多次,起初是打算作为学习笔记的,后来在学习中发现市面上很多教程都是东一点西一点,知识点很分散。所以就打算好好整理一下学到的知识,以便跨行就业或者是零基础的小白用来做入门学习的指南,凝聚Python基础的精髓。
- 我也是今年才选择跨行就业大部队中的一员,希望能和有着共同目标的伙伴一起进步,当然,如果文章中还有什么不详细,有误的地方,请批评指正,最好是给出点指导意见,共同进步,十分感谢!