Python数据类型&运算符&IF分支结构

一、Python中的数据类型

计算机顾明思议就是可以做数学运算的机器,因此计算机理所当然的可以处理各种数据,但是计算机能处理的远远不止数值,还有文本,图形,音频,视频网页等各种数据, 不同数据需要定义不同的数据类型.

str(字符串类型): 用单引号''或者双引号"" 或者 '''  ''' 或者 """  """  包裹起来的文本是字符串
    
Boolean(布尔类型): True(真)  False(假)
    
NoneType(空值):None
   
list(列表):类似于其他语言(C\Java\php\js)中的数组  用 [元素1,元素2,元素3......]来表示
    
tuple(元组):不可修改的列表   用(元素1,元素2,元素3.....)来表示
    
dict(字典):类似于其他语言的(php\js)对象    用 {key:value,key1:value1,key2:value2....}来表示
    
set(集合):了解 {元素1,元素2,元素3.....}
    
bytes(字节):b"文本内容"

代码演示:

# Number数字类型
num = 12
print(type(num))   # <class 'int'>
num1 = 3.14
print(type(num1))  # <class 'float'>

# str 字符串类型
str1 = "hello"
str2 = 'purple'
str3 = """
我是一个大的字符串
使用三个引号
"""
str4 = '''
生前应当少睡,
死后自会长眠
'''
print(type(str1))   # <class 'str'>
print(type(str2))   # <class 'str'>
print(type(str3))   # <class 'str'>

# 布尔类型
bool1 = True
print(type(bool1))   # <class 'bool'>
bool2 = False
print(type(bool2))  # <class 'bool'>

# list列表    列表中的元素可以是各种数据类型
list1 = [12,8.12,"goodbye",True,False]
print(type(list1))   # <class 'list'>

# tuple 元组 不可修改的列表
tup1 = (32,4.13,"miss you",True)
print(type(tup1))   # <class 'tuple'>

# dict 字典
dict1 = {"name":"东儒","age":23,"sex":"**"}
print(type(dict1))   # <class 'dict'>

# set(集合)
set1 = {12,34,"hello",3.23}
print(type(set1))   # <class 'set'>

# bytes(字节)
byte1 = b"world"
print(type(byte1))  # <class 'bytes'>

二、表达式和运算符

1.表达式

操作数和运算符组成的式子就叫做表达式   比如: 1+1
作用:可以用于求值或者给变量赋值等.

2.运算符【掌握】

2.1. 算术运算符

+   -    *【乘法】   /【除法】   %【求余或者取模】  **【求幂或者几次方】  //【取整】

代码演示：

# 1.算术运算符  + - *(乘) /(除)   %(求余或者取模)  **(求幂或者几次方)  //(取整)
num1 = 23
num2 = 3
print(num1+num2)
print(num1-num2)
print(num1*num2)  # 乘法   69
print(num1/num2)  # 除法   7.66666666666
print(num1%num2)  # 取计算后的余数    2
print(num1//num2) # 取计算后的商      7
print(num1**num2) # 求某个数的几次方  12167

2.2. 赋值运算符

简单赋值运算符：= 给一个变量进行赋值

复合赋值运算符：+= -= %= /= ... 给一个变量进行赋值，同时给变量进行相应的运算

代码演示：

# 赋值运算符
# 简单的赋值运算符  将23赋给num1这个变量
num1 = 23
print(num1)
# 复杂的赋值运算符
# num1 = num1 + 11
# num1 += 11    # 等价于 num1 = num1 + 11    结果是34
# num1 -= 11    # 等价于 num1 = num1 - 11    结果是12
# num1 *= 2     # 等价于 num1 = num1 * 2     结果是46
# num1 /= 2     # 等价于 num1 = num1 / 2     结果是11.5
# num1 %= 2     # 等价于 num1 = num1 % 2     结果是1
# num1 **= 3    # 等价于 num1 = num1 ** 2    结果是12167
num1 //= 2      # 等价于 num1 = num1 // 2    结果是11
print(num1)

2.3. 关系【条件，比较】运算符

作用：比较大小，得到结果为布尔值【如果表达式成立，则返回True，如果不成立，则返回False】

>   <   >=    <=    ==【等号】    != 【不等于】

使用场景：if语句，循环

代码演示：

# 关系运算符主要是用于比较大小   返回值是bool类型  表达式成立返回True  表达式不成立返回False
a = 23
b = 46
c = 23
print(a > b)  # False
print(a < b)  # True
print(a == b) # False
print(a == c) # True
print(a != b) # True
print(a >= b) # False
print(a <= b) # True
print(a >= c) # True
print(a <= c) # True

2.4. 逻辑运算符

and : 与, 并且

or： 或, 或者

not：非, 取反

逻辑操作符and 和or 也称作短路操作符(short-circuitlogic)或者惰性求值(lazy evaluation)：它们的参数从左向右解析，一旦结果可以确定就停止。

因为and运算符必须所有的运算数都是True才会把所有的运算数都解析，并且返回最后一个变量.

而或逻辑(or)，即只要有一个是True，即停止解析运算数，返回最近为True的变量，

# and(与) or(或) not(非)

# and 只有表达式两边都为真,则整个表达式的结果才为真
'''
print(True and True)
print(False and True)
print(True and False)
print(False and False)
'''
# or  只要有一个表达式为真,则整个表达式的结果为真
'''
print(True or True)
print(True or False)
print(False or True)
print(False or False)
'''
# not
'''
print(not True)
print(not False)
print(not [])   #  []空列表 是False
print(not {})   #  {}空字典 是False
print(not ())   #  ()空元组  是False
print(not None) # None 是False
'''
# and 或者 or的短路操作
'''
# print(not 0)   # 数字0 为False
print(0 and 12)  # 0
print(12 and 0)  # 0
print(12 and 9)  # 9
print(9 and 12)  # 12
'''

# or的短路运算
print(3 or 0)  # 3
print(0 or 3)  # 3
print(14 or 8) # 14

# 练习:判断2020年是否是闰年    能被4整除并且不能被100整除  就是闰年
year = 2020
print(year % 4 == 0 and year % 100 != 0)

2.5. 成员运算符和身份运算符

成员运算符:

​ in, not in

身份运算符:(了解)

​ is, is not

# 成员运算符  in 和 not in
'''
print(2 in [12,34,56,8,9,32,2])  # True
print(2 in [12,34,56,8,9,32])    # False
print(2 not in [12,34,56,8,9,32])   # True
print("welcome" in "welcome to shenzhen")  # True
print("猪猪侠" in ["闪电侠","钢铁侠","蜘蛛侠","蝙蝠侠","绿箭侠","煎饼侠"]) # False
print("猪猪侠" not in ["闪电侠","钢铁侠","蜘蛛侠","蝙蝠侠","绿箭侠","煎饼侠"]) # True
'''
'''
# 判断输入的月份是否是31天
month = int(input("请输入月份:"))
print(month in [1,3,5,7,8,10,12])
'''

# 身份运算符   is 或者 is not   主要用于判断内存地址是否相同
# id() 获取内存地址
x = 12
y = 12
print(id(x))
print(id(y))
print(x is y)   # True
print(x is not y) # False

2.6. 位运算符【扩展】(了解)

a = 60 二进制 00111100

b = 13 二进制 00001101

&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

前提：将数字转换为二进制使用

&【按位与】 |【按位或】 ^【按位异或】 << 【左移】 >>【右移】

代码演示：

# 位运算符 (了解)
a = 60    # 二进制     00111100
b = 13    # 二进制     00001101
print(a & b) # ===>   00001100  => 1*2^3+1*2^2+0+0 = 12
print(a | b) # ===>   00111101  => 1*2^5 + 1*2^4 + 1*2^3 + 1*2^2 + 0 + 1 = 32+16+8+4+1 = 61
print(a ^ b) # ===>   00110001  => 1*2^5 + 1*2^4 + 1 = 49

三、分支【重点掌握】

1.代码结构

顺序结构：代码从上往下依次执行

分支结构：根据不同的条件，执行不同的语句

循环结构: 根据指定的条件，重复执行某段代码

2.分支结构-if语句

2.1简单if语句【单分支】

语法：

if 表达式：

​ 执行语句

说明; 要么执行，要么不执行，当表达式成立的之后，则执行语句；如果表达式不成立，则直接跳过整个if语句继续执行后面的代码

注意：表达式为真才执行语句

​ 假：0 0.0 False " " ' ' None【空值】 [] {} ()

​ 一般情况下，表达式使用都是比较运算符

代码演示：

'''
表达式成立的情况:
a = 19
b = 4
if a > b:
    print("a>b成立")
print("今天天气好晴朗")
'''

# 表达式不成立的情况
'''
a = 19
b = 4
if a < b:
    print("a>b成立")
print("今天天气好晴朗")
'''


# 练习
age = int(input("请输入你的年龄:"))
if age >= 18:
    print("恭喜你成年了,可以干一些成年人的事情了!")

2.2if-else语句【双分支】

语法：

if 表达式：

​ 执行语句1

else:

​ 执行语句2

说明：如果表达式成立，则执行语句1；如果不成立，则执行语句2 if区间的语句和else区间的语句永远不会同时出现.

代码演示：

'''
# 在控制台输入一个数字,判断是否是偶数
num = int(input("请输入一个数字:"))
if num % 2 == 0:
    print("是偶数")
else:
    print("是奇数")
'''
str = input("说出你的心里话:")
if str == "喜欢":
    print("小女子今生无以为报,只能以身相许")
else:
    print("小女子今生无以为报,只能来世做牛做马报答公子大恩")

2.3if-elif-else语句【多分支】

语法：

if 表达式1：

​ 执行语句1

elif 表达式2：

​ 执行语句2

elif 表达式3：

​ 执行语句3

。。。。。

else:

​ 执行语句n

说明：实现了多选一的操作，会根据不同的条件从上往下来进行匹配，如果匹配上了，则执行对应的语句，然后直接结束整个if-elif语句，但是，如果所有的条件都不成立的话，则执行else后面的语句

注意：不管if-elif-else有多少个分支，都只会执行其中的一个分支

代码演示：

'''
if 表达式1:
    语句块1
elif 表达式2:
    语句块2
elif 表达式3:
    语句块3
else:
    其他语句
注意: 从上往下匹配,只要满足期中一个条件则执行其中的语句块,
'''


'''
成绩 >= 90   优秀
成绩 >= 80   良好
成绩 >= 70   及格
成绩 70以下   加油吧,骚年!
score = int(input("请输入你的成绩:"))
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("及格")
else:
    print("加油吧,骚年!")
'''

'''
1000000以上 高收入
500000      中产
200000      低产
20万以下     贫困户
'''
money = int(input("请输入你的年收入:"))
if money >= 1000000:
    print("高收入,恭喜能在深圳买个厕所")
elif money >= 500000:
    print("中产,恭喜能在老家省会城市付首付")
elif money >= 200000:
    print("低产,恭喜能在老家县城付首付")
else:
    print("能在农村盖个茅房")

2.4嵌套if语句

语法：

if 表达式1：

​ 执行语句1

​ if 表达式2：

​ 执行语句2

说明：if语句的嵌套，可以在单分支，双分支，多分支之间进行任意组合

代码演示：

'''
多金   肤白   嫩美   大长腿  

'''
money = int(input("请输入你的财富:"))
skin = input("请输入你的肤色:")
age = int(input("请输入你的年龄:"))
leg = input("请输入腿长:")

if money >= 20000000:
    if skin == "肤白":
        if age <= 18:
            if leg == "大长腿":
                print("求求你包养我吧!")
            else:
                print("腿太短了,加一节吧")
        else:
            print("年龄太大了,不是我的菜")
    else:
        print("我喜欢皮肤白的,不喜欢黑的")
else:
    print("钱太少了,软饭不够我吃")

注意：从语法角度来说，嵌套的层数没有任何的限制，但是，为了代码的可读性和可维护性，嵌套层数不要超过3层

总结:

1.python中常见的数据类型:
    int float str bool list tuple dict NoneType set bytes
2.运算符:
    算术运算符: + - * / % // **
    赋值运算符: =(赋值) += -= /= %= //= 
    比较运算符: > < >= <= == !=
    逻辑运算符: and or not
   	成员运算符:in not in 
    身份运算符:is  is not (了解)
    位运算符: & |  ^  >>  <<   (了解)
3.分支结构
	单分支:
        if 表达式:
            语句1
    双分支:
        if 表达式:
            语句1
        else:
            语句2
    多分支:
        if 表达式1:
            语句1
        elif 表达式2:
            语句2
        elif 表达式3:
           	语句3
        else:
            语句4
    if嵌套:
        if 表达式1:
            if 表达式2:
                if 表达式3:
                    语句