python入门第四课--数据类型、格式化输出、解压赋值、逻辑运算符，成员运算符，2.只有两种状态Tr
python入门第四课--数据类型、格式化输出、解压赋值、逻辑运算符，成员运算符，2.只有两种状态Tr
今日内容概要
- 作业讲解
- python基本数据类型
- 与用户交互
- 格式化输出
- 基本运算符
- 多种赋值方式 常用赋值符
- 逻辑运算符
- 成员运算符
- 身份运算符
- 流程控制理论
今日内容详细
作业讲解
# 附加练习题(提示:一步步拆解)
# 1.想办法打印出jason
l1 = [11,
22,
'kevin',
['tony',
'jerry',
[123,
456,
'jason']
]
]
'''分步操作'''
1. 先看大列表到底有几个数据值 以及我们想要的数据值在哪个里面
print(l1[3])
l2 = l1[3] # ['tony', 'jerry', [123, 456, 'jason']]
2. 再次思考小列表有几个数据值 以及我们想要的数据值在哪个里面
print(l2[2])
l3 = l2[2] # [123, 456, 'jason']
3. 最后转化成了简单的索引直接取值
print(l3[2])
'''简化操作'''
print(l1[3][2][2])
2. 想办法打印出大宝贝
d1 = {'name': 'jason',
'others': {'a1': 'heiheihei',
'a2': {'k1': 'hahaha',
'k2': 'hehehe',
'k3': '大宝贝'}
}
}
'''分步操作'''
1. 先拿大字典第二个键值对的值
print(d1['others'])
d2 = d1['others'] # {'a1': 'heiheihei', 'a2': {'k1': 'hahaha', 'k2': 'hehehe', 'k3': '大宝贝'}}
2. 再拿小字典第二个键值对的值
print(d2['a2'])
d3 = d2['a2']
3. 转化成简单的按k直接取值
print(d3['k3'])
'''简化操作'''
print(d1['others']['a2']['k3'])
3. 想办法打印出run
data = {'username': 'jason',
'hobby': [11,
22,
{'height': 183,
'hobby': ['read',
'run',
'music'
]
}
]
}
'''分步操作'''
print(data['hobby'])
data1 = data['hobby'] # [11, 22, {'height': 183, 'hobby': ['read', 'run', 'music']}]
print(data1[2])
data2 = data1[2] # {'height': 183, 'hobby': ['read', 'run', 'music']}
print(data2['hobby'])
data3 = data2['hobby'] # ['read', 'run', 'music']
print(data3[1])
'''简化操作'''
print(data['hobby'][2]['hobby'][1])
.
.
1. python基本数据类型
1.1 基本数据类型之布尔值bool
1.作用： 用来判断事物的对错 是否可行 主要用于逻辑运算或流程控制中。
2.只有两种状态
True 对的 真的 可行的
False 错的 假的 不可行的
3.python中所有数据都自带布尔值
布尔值为False的数据类型有: 0 None '' [] {} （）
布尔值为True的数据类型有: 除了上面的都是True
4.存储布尔值的变量名一般推荐使用is开头
is_delete = False
is_alive = True
"""
很多程序中提供的注销账户的功能 其实底层并没有删除数据 而是修改了数据的状态
所谓的数据删除很多时候并不是真正的删，而是把某一个字段的状态改一下，然后通过代码逻辑来删除，让用户感觉不到。
id username password phone is_delete
1 jason 123 110 1 当用户注销的时候，系统只把0改为1就行了
2 kevin 321 120 0
"""
1.2 基本数据类型之 元组tuple （数据值, 数据值, 数据值, 数据值）
元组所使用的场景：程序自动返回的一些数据类型，一般都是用元组来代替，因为元组表示索引不能改。
1. 也称为'不可变'的列表，元组内索引与数据值的绑定关系不能修改。
2. 小括号（）括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 数据值可以是任何数据类型
和列表的唯一的区别就是，元组是用的（）小括号，而列表是用的[]方括号。
3. 代码实现
t1 = (11, 22, 'jason')
4. 元组与列表的对比
列表：
list1 = [11, 22, 33]
print(list1[0]) # 获取索引0对应的数据值
list1[0] = 666 # 666与列表索引0，绑定
print(list1) # 结果如下
[666, 22, 33]
元组：
t1 = (11, 22, 33)
print(t1[0])
t1[0] = 999 # 这一步，想让999与索引0绑定，但是元组内数据值与索引的绑定关系是不能解除的
print(t1) # 结果报错
TypeError类型错误
面试例题：
t1 = (11, 22, [111, 222]) # 这是一个元组数据
t1[2][1] = 666
# 元组内的索引与数据值的绑定不能修改，但现在改的是元组内-列表内-索引与数据值的关系，也就是说元组内的列表，列表中索引与数据值是可以重新绑定的。
print(t1)
(11, 22, [111, 666])
.
5. 注意： 元组内如果只有一个数据值，数据值的后面逗号不能省略！！！
否则电脑电脑不认这个数据为元组。括号里面如果是单个数据，你放什么数据类型，加了一个括号后还是原来的数据类型，不会变成元组！！！
会把括号里面的数据当成数据类型。如下
t1 = (1) # 如果元组里面只有一个数据，电脑会把1当作数据类型进行判。int
t2 = (11.11) # 如果元组里面只有一个数据，电脑判断为float
t3 = ('jason') # 如果元组里面只有一个数据，电脑判断为str
print(type(t1), type(t2), type(t3)) # 类型结果是
<class 'int'> <class 'float'> <class 'str'>
元组内单个数据后，加了逗号，电脑就会判断出该为元组了。
t1 = (1,)
t2 = (11.11,)
t3 = ('jason',)
print(type(t1), type(t2), type(t3)) # 类型结果是
<class 'tuple'> <class 'tuple'> <class 'tuple'>
"""
建议:以后在使用可以存放多个数据值的数据类型时 如果里面暂时只有一个数据值 那么也建议你加上逗号
"""
.
.
.
.
1.3 基本数据类型之 集合set
1. 集合只能用于去重和关系运算 后面再讲 暂且忽略
2. 集合内数据只能是不可变类型 后面再讲 暂且忽略
3. 大括号括起来 内部存放多个数据值 数据值与数据值之间逗号隔开 ，集合与列表很像，就是括号不一样，
与字典的区别：集合里面的数据值不是k:v键值对
4. 代码实现
s1 = {数据值, 数据值, 数据值, 数据值}
集合内数据是无序的，不支持索引取值！！！！！！！！！
5. 定义空集合与空字典 {} 默认是字典 set() 定义空集合
.
.
2. 程序与用户交互 input（） print（）
强调:input获取到的数据都会统一处理成字符串类型。应为python默认情况下是不支持不同的数据类型之间做一些的操作的。
1.获取用户输入
input（） # 等待用户输入 ， 括号里面可以输入提示信息比如'请输入密码:'
username = input('请输入您的用户名:')
"""
1.先执行input获取用户输入
2.将输入的数据绑定给变量名username
3.以后在程序中就可以使用变量名反复调用用户数据
"""
-----------------------------------------
2.输出内部信息 print（）
*** 注意括号里面是字符串时要用''引号引起来，但是如果是变量名时，则不需要引号引起来。
2.1. 括号内既可以放数据值也可以放变量名，并且支持多个变量名，逗号隔开可一次性打印多个。
比如可以 print（123， 321，213）
也可以name = 'jason'
print（name, name, name）
2.2. print（）自带换行符，就是如果你print（）括号里面什么都不写直接运行，电脑自动空一行。
换行符:\r\n 或 \n
(斜杠与字母组合到一起可能会产生特殊的含义)
-----------------------------------------
3.print也可以切换结束符
print('jason', end = '') # end默认是换行符 \n ，此处将end定以为空之后,相当于去除了该print的换行。
print('jason') # 所以当运行这两个print后，结果如下
jasonjason
*** 看代码的源码：按住Ctrl键，左键点代码，就能看到该代码的底层源码。
-----------------------------------------
***面试题目 扩展:python2与python3中两个关键的区别？
1.1 python2中 input（）获取用户数据时，需要用户自己提前指定数据类型，写什么类型，就认为是什么类型。
你输入整数，获取的数据就是整形，你输入列表，获取的就是list。
1.2 python2中 raw_input（）获取用户数据时方法与python3中input一致 输入的统一处理成字符串。
2.1 python2中print的使用方法有两种：
可以是 print 数据值 也可以是 print(数据值)
2.2 python3中print的使用方法只有 print(数据值)
.
.
.
在python2的终端里，可以不用输入print（）， 直接写变量名，就可以直接打印。
如果非要写print不写括号，空一格再写变量名，也可以打印，与python3的用法有点小区别。
.
.
3. 格式化输出 一般用在字符串类型的数据 经常要用，很重要！！！
#### %s的作用是占位置， %后面放需要替换到%s地方的内容！！！
#### print('my name is %s my age is %s' % ('jason', 18, 'read')) 可以一起用！
#### 多了不行，会报错
提前定义好一些内容 将来需要使用的时候可以局部修改 eg:奖状、录取通知书、合同
.
代码实现：
但是在程序中需要使用占位符: %s 与 %d
%s常见数据类型都支持给占位 %d只支持给数字占位
1. 单个占位符情况
info = '%s同志你好'
print(info % 'Jason') # 变量名 % 后面放一个'jason'它就会自动替换%s，变成如下：
Jason同志你好 # 注意 %号后需要替换 %s的数据是 字符串型 时要用'' 引起来。
也可以不用变量名，直接用数据，如下！！！！！
info = '%s同志你好'
print('%s同志你好' % 'Tony') # 也能打印出结果
Tony同志你好
.
2. 多个占位符
desc = '姓名:%s 年龄:%s 爱好:%s'
print(desc % ('jason', 18, 'read')) # 注意当要替换 %s的字符的是变量时，就不需要引号引起来了。结果如下：
姓名:jason 年龄:18 爱好:read
也可以不用变量名，直接用文本数据
print('姓名:%s 年龄:%s 爱好:%s' % ('tony', 28, 'rap'))
注意： 多个占位符时，百分号% 后面需要接一个元组，元组里面要把每一个要加的信息都写进去。
所以上面的两个也可以写成：
print(info % ('jason',)) # 这是利用多占位符的格式写的
print('%s同志你好' % ('Tony',)) # 这是利用多占位符的格式写的
注意事项: 字符串里面有几个占位符，%后面就需要几个数据值！！！！
print('my name is %s my age is %s' % ('jason',)) # 少了不行，会报错
print('my name is %s my age is %s' % ('jason', 18, 'read')) # 多了不行，会报错
.
'''不同占位符的区别'''
demo1 = '%s您好 您本月的话费是%s 余额是%s' # %s常见数据类型都支持
print(demo1 % ('jason', 100, 10000000000000)) # 结果如下
jason您好 您本月的话费是100 余额是10000000000000
demo2 = '%d您好 您本月的话费是%d 余额是%d'
print(demo2 % ('tony', 1000000000, -100000)) # %d只支持数字类型，所以会报错。
TypeError：
print('%08d'% 123) # 百分号可以产生固定位数的数字，08d就是展示8位，如果不够用0补齐 结果如下
00000123
print('%08d'% 1234324324) # 1234324324 # 后面数字比前面要求的位数多，就不管前面的占位指令了。
.
.
4. 基本运算符
1. 数学运算符
加+ 减- 乘* 除/ 取余% 整除// 指数符**
一些赋值运算的简化写法：死记硬背规则
n = 10
n += 1 # 相当于 n = n + 1
n -= 1 # n = n - 1
n *= 1 # n = n * 1
n /= 1 # n = n / 1
n %= 1 # n = n % 1
n //= 1 # n = n // 1
n **= 1 # n = n ** 1
2. 比较运算符
< > 小于等于<= 大于等于>= ==(等于号) !=(不等于)
.
.
5. 多种赋值方式
1. 链式赋值
name = 'jason'
name1 = name
name2 = name
链式赋值转化为：
name = name1 = name2 = 'jason'
------------------------------------
2. 交叉赋值
m = 100
n = 999
要求：让m和n互相转换绑定的值
* 错误写法：
m = n # 这句话意思是让999绑定给m，也就是m与100没关系了。
n = m # 这句话意思是让999绑定给n。
print(m, n) # 所以打印出结果为：
999 999
* 方式1:采用中间变量
temp = m
m = n
n = temp
print(m, n) # 采用中间变量，可以互换mn结果，结果如下：
999 100
* 方式2:交叉赋值语法
m, n = n, m
print(m, n) # 这种方法最简单
999 100
.
3. 解压赋值 重要！！！
name_list = ['jason', 'kevin', 'tony', 'oscar']
要求：把列表里面的每个数据值用另一种变量名来指代一下。
1. low的写法：
name1 = name_list[0]
name2 = name_list[1]
name3 = name_list[2]
name4 = name_list[3]
3.1. 解压赋值语法：
name1, name2, name3, name4 = name_list # 这句话就等价于上面的4句代码。
'''解压赋值在使用的时候 正常情况下需要保证左边的变量名与右边的数据值个数一致'''
a, b = name_list # 变量名少了不行，会报错
a, b, c, d, e = name_list # 变量名多了也不行，会报错
'''当需要解压的数据个数特别多 并且我们只需要使用其中头尾几个时，那么可以打破上述的规则'''
name_list = ['jason', 'kevin', 'tony', 'oscar']
第一种：
a, *b = name_list # *会自动接收多余的数据，并组织成列表赋值给后面的变量名。
print(a)
jason
print(b)
['kevin', 'tony', 'oscar']
同理：
a, c, *b = name_list
print(a)
jason
print(c)
kevin
print(*b)
['tony', 'oscar']
------------------------------------
第二种：两头拿数据：
name_list = ['jason', 'kevin', 'tony', 'oscar']
a, *b, c = name_list # *会自动接收多余的数据，并组织成列表赋值给后面的变量名。
print(a)
jason
print(b)
['kevin', 'tony']
print(c)
oscar
------------------------------------
'''当数据值不准备使用的时候，可以使用下划线作为变量名绑定'''
a, *_, c = name_list # 给别人一个信息，*号接收的数据，暂时我用不到。
.
.
6. 逻辑运算符 主要配合条件一起使用
1. and 与
and连接的必须是一个具体的数据值或者是一个具体的运算符。
多个条件必须全部成立 结果才成立
例如：
print（1 > 2 and 4 < 8 and 10 < 1 and 1 == 2） # 只要发现一个不成立 结果就不成立
False
print(1 < 10 and 666) # 首先判断前面第一个条件成立，再看and后面的如果是具体的数据就直接报具体的数据。电脑就是这么设置的，没有为什么。结果就是666 。
666
print(1 < 10 and 2 < 8) # 前面第一个条件成立，and后面的如果是还是比较的判断的关系，那就报布尔值。
True
print(111 and 222) # 第一个111是成立的，所以完全取决于and后面的数据，and后面又是一个具体的数据值，所以直接报222 。
222
-------------------------
print(1 > 10 and 2 > 10) False
print(1 < 10 and 2 > 10) False
print(1 > 10 and 2 < 10) False
print(1 < 10 and 2 < 10) True
and的左右两边必须都是True 结果才能是True ！！！
-------------------------
*** and的判断法则：
如果and左边的条件是成立的 那么就完全取决于右边的条件
右边如果直接是数据值 那么结果就是该数据值 如果是含有表达式 则为布尔值
.
2. or 或
or连接的多个条件只要有一个成立 结果就成立
如果条件中全部由or组成那么判断起来非常的简单 只要发现一个成立 结果就成立。
print(1 < 10 or 666) # 第一个条件已经成立了，不用看后面的条件了，直接报布尔值了。
True
print(666 or 1 > 10) # 具体数字代表的布尔值为true已经成立了，又是具体的数值，直接报具体数值。
666
print(0 or False) # 0代表的布尔值是不成立，再看or后面的还是False，所以报False 。
False
print(0 or 111) # 0代表的布尔值是不成立，再看or后面的，是具体数字，直接报具体数字 。
111
.
3. not 非
取反
类似于说反话
4. 注意：
三者混合使用的时候有优先级之分 但是我们不需要记忆优先级
应该通过代码的形式提前规定好优先级
可以使用括号来改变优先级,比如
print( (3>4 and 4>3) or ((1==3 and 'x' == 'x') or 3 >3))
False
.
.
7. 成员运算符 个体in群体
群体可以是列表、字符串、字典、元组、集合
判断个体在不在群体内，并会得出逻辑判断的结果就是一个布尔值。
1. 列表的情况
name_list = ['jason', 'kevin', 'oscar', 'jerry']
print('tony' in name_list) # 相当于问tony在不在列表里？'tony' 不在列表里面，所以结果如下：
False
print('tony' not in name_list) # 这个in前面加了not，相当于问tony不在列表里，对不对？
True
print('j' in name_list) # 列表最小单位是数据值，不能再细分，所以判断'j'不在列表里面。
False
--------------------------------------
2. 字符串的情况
s1 = 'hello world' # 字符串整体也可以做成员运算。
print('d' in s1) # 字符串最小单位是单个单个的字符
True
--------------------------------------
3. 字典的情况
d1 = {'username': 'jason','pwd': 123}
print('jason' in d1) # 字典在做成员运算时，只有键参与，值不参与
False
print('username' in d1) # 在这个字典里，只能输入键'username'或'pwd'，而不能输入值，来进行成员运算。所以结果如下：
True
.
.
.
.
8. 身份运算符 is 源码里用的较多
python中的is是一个身份运算符，它能够用来判断两个对象是否完全相同，并返回一个结果True或False
--------------------------------------------------------
源码例题:
self.is_bound = data is not None
# data变量名对应的值是否是not None(非空),如果是not None, 这行代码data is not None 的返回结果就是True self.is_bound = True
# 同理如果data变量名对应的值是none,这行代码data is not None 的返回结果就是False self.is_bound = False
---------------------------
A = []
B = None
C = [1, 2]
print(A is not None) True 注意空字典与空列表不是none，也是非None
print(B is not None) False
print(C is not None) True
print(not A) True 空字典与空列表的布尔值是False，但它们自身不是None
print(not B) True None的布尔值也是False
print(not C) False
--------------------------------------------------------
--------------------------------------------------------
is 是否是 判断内存地址是否相同 如果是返回True 否则返回False
== 是否等于 只判断数据值是否相同 如果等于返回True 否则返回False
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
l2 = [11, 22, 33, 44, 55, 66, 77, 88]
print(l1 == l2) # 判断这两个变量名所绑定的值是否相同？
True
print(id(l1)) # 意思相当于是查一下变量名L1所绑定的数据在内存地址里所在的位置。
print(id(l2)) # L1于L2这两个虽然数据值是一样的，但是在内存地址里所在的位置不一样。
print(l1 is l2) # 所以判断结果为False
False
id(变量名) 该方法返回一串数字，该数字可以看成是变量名的内存地址
--------------------------------------------
小整数池： 是电脑自身的优化，将数据量比较小数据自动识别出来，就会在存储空间里面直接合并了。
i1 = 11
i2 = 11
print(i1 is i2) # 所以结果为
True
s1 = 'jason jason jason'
s2 = 'jason jason jason'
print(s1 is s2)
不同的环境下可能优化的程度不一样，比如pycharm软件与python解释器对于同一个身份运算的结果可能不一样。python解释器会更优化一点，把一些较小的数据识别出来，并输出True。
"""
了解
值相同 内存地址可能不同
内存地址相同 值肯定相同
"""
总结：逻辑运算符 and in not 以及成员运算符in，及身份运算符is，他们的语句执行完后都会得出一个布尔值出来，这也就是后面if，while等判断条件所进行判断的依据 ！！！
评论关闭