python入门第四课–数据类型、格式化输出、解压赋值、逻辑运算符，成员运算符

今日内容概要

• 作业讲解
• 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（）括号里面什么都不写直接运行，电脑自动空一行。
换行符:rn  或   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等判断条件所进行判断的依据 ！！！