day01-python基础语法学习

stiinput

已于 2022-09-22 19:40:22 修改

阅读量937

点赞数 1

分类专栏： Python知识集文章标签： python 学习开发语言 pycharm 职场和发展

于 2022-09-11 20:23:52 首次发布

本文链接：https://blog.csdn.net/Z_qin007/article/details/126808803

版权

Python知识集专栏收录该内容

20 篇文章 2 订阅

订阅专栏

Python基础语法学习

一、注释

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基础的精髓。
我也是今年才选择跨行就业大部队中的一员，希望能和有着共同目标的伙伴一起进步，当然，如果文章中还有什么不详细，有误的地方，请批评指正，最好是给出点指导意见，共同进步，十分感谢！

stiinput

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
day01-python基础语法学习

摘要：改文章主要讲述了python的基础语法内容，包括变量、常量、标识符、关键字运算符、内置函数、内置数据类型在内的五大部分，详细的介绍了python的基础语法，最后一章讲述的是计算机基础里边的进制转换。
复制链接

扫一扫