上周内容整合6.26

上周内容整合6.26

基本数据类型

数据类型可以简单的理解为代码中不同情况下不同类型数据的状态

基本数据类型之整型

整型（int）

整型主要运用于数学运算，没有内置方法本质就是记录与数字相关的状态。

  1. 基本使用

    直接定义，将一个数字用赋值符号捆绑给变量名。

    # 示例：
	age = 18
# 变量名+赋值符号+整数

  2. 整型的类型转换

    关键字int（）括号里输入需要转换到整型的数据

    age = int()  # 里面输入待转换的数据
# 1.首先我们来看一下有那些不能转换为整型
print(type(int('123')))  # 可以转换
print(type(int('123a321')))  # 不能转换
# 字符串内部必须是纯数字情况才可以转换
print(type(int('123.33')))  # 不能转换
# 带有小数点的数字也不行

  3. 进制转换。

    进制数分别为二进制、八进制、十进制、十六进制。

    1. 十进制转换成其他进制

      如果数字前面没有任何标识 默认就是十进制。

    print(bin(200))  # 0b11001000 关键字bin，将十进制转成二进制。
print(oct(200))  # 0o310 关键字oct，将十进制转成八进制。
print(hex(200))  # 0xc8 关键字hex，将十进制转成十六进制。
    1. 其它进制数转换为十进制。
    # 自动识别进制数
print(int(0b11001000))  # 200
print(int(0o310))  # 200
print(int(0xc8))  # 200
# 人为指定进制数
print(int('0b11001000', 2))  # 200
print(int('0o310', 8))  # 200
print(int('0xc8', 16))  # 200
基本数据类型之浮点型

浮点型（float）

浮点型主要用于记录与小数相关的数据状态，它也没有内置方法。

  1. 基本使用

    直接定义，将一个小数用赋值符号捆绑给一个变量名

    # 示例：
	salary = 1.5
# 变量名+赋值符号+小数

  2. 浮点型的类型转换

    关键字float（）括号里输入需要转换到浮点型的数据

    salary = float()  # 里面输入待转换的数据
# 1.首先我们来看一下有那些不能转换为浮点型
print(float('123'))  # 123.0 可以转换
print(float('123a123'))  # 不可以
print(float('123.12'))  # 可以识别一个小数点
print(float('123.123.1.2.2.2.2.2.2'))  # 不可以

  3. 针对布尔值的特殊情况

    print(float(True))  # 1.0
print(float(False))  # 0.0
基本数据类型之字符串

字符串（str）

作用于具有描述性的信息，它应用的场景非常多其内置方法也有很多。

  1. 基本使用

    它是由引号引起来的一串字符有四种方式根据不同应用场景引用不同的方式

    # 分别有单引号、双引号、三引号、三个双引号
name = 'toy'
name = "iack"
name = '''名字'''
name = """这是一个名字"""

  2. 类型转换

    字符串兼容所有数据值都可以转换为字符串。

    print(str(123), type(str(123)))
# 整型可以
print(str(123.11), type(str(123.11)))
# 浮点型也可以
print(str([1, 2, 3, 4]), type(str([1, 2, 3, 4])))
# 列表也可以
print(str({'name': 'jason'}), type(str({'name': 'jason'})))
# 字典也可以
print(str(True), type(str(True)))
# 布尔值也可以
print(str((1, 2, 3, 4)), type(str((1, 2, 3, 4))))
# 元组也可以
print(str({1, 2, 3, 4}), type(str({1, 2, 3, 4})))
# 集合也可以

  3. 字符串的内置方法

    首先字符串调用的内置方法不是改变了原来的数据值，而是从原来的数据值上拷贝下来产生了一个新值。不会改变原来的数据值。

    1. 字符串字符取值、切片，需要根据字符串具体数量按索引位置取值、切片。位置超出直接报错！！！

      # 示例1：  单个字符取值。
name = 'abcdefg'
print(name[1])  # b  按索引取值、正向取
print(name[-2])  # f 索引取值、反向取
# 示例2：  多个字符取值、切片。
name = 'abcdefg'
print(name[:])  # abcdefg   只放冒号默认取全部值
print(name[:2])  # ab       冒号后面跟着2代表从头开始取俩个数值
print(name[::2])  # aceg    按照间隔为2的方式取全部值
print(name[0:5:1])  # abcde   从0开始取到第5个数据值。
print(name[0:5:2])  # ace   从0开始取到第5个数据值间隔为1
#   取值都是顾头步顾尾！！！
print(name[-1:-3:])  # 取不到 默认顺序从左往右
print(name[-1:-3:-1])  # gf 反向取值按照索引从-1到-3取值。
print(name[-1:-7:-2])  # ge 反向取值按照索引从-1到-7取值，然后间隔为1
print(name[-1:-6:-3])  # gd 反向取值按照索引从

    2. 统计字符串的数量（len）

      name = 'abcdefg'
name1 = 'abc de fg'
print(len(name))  # 7    使用关键字len括号里输入要查询的字符串。
print(len(name1))  # 9   其中空格也算字符串里面的一员。

    3. 移除字符串首尾的字符（.strip()）

      name = '  abcdefg  '
name1 = '  ab cd efg  '
name2 = '|||  ab|cd |efg  |||'
print(name.strip())  # abcdefg  去掉首尾的空格。
print(name1.strip())  # ab cd efg  去掉首尾空格中间是不会去的。
print(name2.strip('|'))  #   ab|cd |efg    把你想要去除的符号输入进去，只去掉首尾符号中间是不会去除的。
print(name3.strip('#''$''%’))  # 也可以去除多个字符

    4. 移除字符串左边的指定字符(.lstrip())

      name1 = '|abcdefg|'
print(name1.lstrip('|'))  # abcdefg|  只去除左边的符号

    5. 移除字符串右边的指定字符(.rstrip())

      name2 = "ab|cd|ef|g||"
print(name2.rstrip('|'))  # ab|cd|ef|g  只去除右边的符

    6. 按照指定字符来切割字符串中全部的特殊符号（.split（））

      name = '  ab|cd|efg  '
name1 = '  ||ab ||cd efg  '
name2 = '|ab|cd|efg|'
print(name.split())  # ['ab|cd|efg']  如果不输入任何参数则默认是空格，会删除空格将其改变成一个列表。
print(name1.split('|'))  # ['', 'ab', 'cd', 'efg', '']
print(name2.split('|'))  # ['', 'ab', 'cd', 'efg', '']
name1 = '  ||ab ||cd 123  '
name2 = "ab|cd|ef|g"。
print(name1.split('|', maxsplit=1) ) # ['  ', '|ab ||cd efg  '] 从左边切割切一次。

    7. 与字符串中字母相关的内置方法，（.lower将字符串中字母全部替换为小写）、（.upper将字符串中字母全部替换为大写）、（.islower判断字符串中是否全部为小写字母）、（isupper判断字符串中是否全部为大写字母）。

      name1 = '|abcdefg|'
name2 = "Ab|Bd|Cf|gH 
print(name2.lower())  # ab|bd|cf|gh|| 将字符串中大写字母改为小写。
print(name1.upper())  # |ABCDEFG|     将字符串中小写字母全部改为大写。
print('AAA'.islower())  # False  判断字符串中是否全为小写字母。
print('AAA'.isupper())  # True   判断字符串中是否全为大写字母。

    8. 字符串中的格式化输出方式。（.format）、（.f”“）

      # 示例1： 等同于%S没什么优势。
name3 = "a{}c{}e{}g"  # 按照索引对应位置传值，少一个都不行
print(name3.format('b', 'd', ))  # 少一个直接报错
print(name3.format('b', 'd', 'f'))  # 打印结果：abcdefg
# 示例2：
name4 = "a{0}c{1}e{2}g{0}{2}{1}{0}"  # 支持索引取值 并且可以重复使用
print(name4.format('b', 'd', 'f'))  # 输出结果：abcdefgbfdb
# 示例3：
name2 = "a {l} ab {l} b {l} {t} "  # 支持关键字取值，可以重复使用。
print(name2.format(t='123', l=456))  # 输出结果： a 456 ab 456 b 456 123
# 示例4：
a = '123'
b = '789'
name1 = f'{a}|abc{b}de{b}fg|{a}'  # 推荐使用
print(name1)  # 123|abc789de789fg|123

    9. 统计字符串中指定字符出现的数量（.count（））

      pwssword1 = "qazwsxedcedcxswqaz"
print(pwssword1.count('qa'))  # 2

    10. 判断字符串中是不是以指定字符开头或者结尾的。（.startswith判断是不是以什么开头）、（.endswith判断是不是以什么结尾）。

      pws1 = 'xaz wsx edc xx ed cxs wq az'
print(pws1.startswith('x'))  # True  判断字符串是不是以x开头
print(pws1.startswith('az'))  # True 判断字符串是不是以az开头
print(pws1.startswith('edc'))  # Flase 判断字符串是不是以edc结尾
print(pws1.endswith('heiheihei'))  # False 判断字符串是不是以heiheihei结尾

    11. 将字符串中指定字符替换为其他字符（.replace）。

      pws1 = 'xaz wsx edc xx ed cxs wq az'
print(pws1.replace('x','0')) # x是需要换掉的0是需要加进去的从左往右全部换掉
# 0az ws0 edc 00 ed c0s wq az

print(pws1.replace('az','111',1))  # 从左往右替换指定个数
# x111 wsx edc xx ed cxs wq az

    12. 字符串的拼接（.join）。

      name = 'toy'
name1 = 'tommm'
print(name+name1)  # toytommm 字符串支持加法拼接，也支持乘号。
print(name*10)  # toytoytoytoytoytoytoytoytoytoy 
name = 'toy'
name1 = 'tommm'
print(name+name1)  # toytommm 字符串支持加法拼接，也支持乘号。
print(name*10)  # toytoytoytoytoytoytoytoytoytoy
print('|'.join(['123','456','789']))  # 123|456|789   将列表链接成字符串
print(''.join(['123','456','789']))  # 123456789
print('d'.join(['123','456',789]))  # 列表中的数据都必须是字符串类型否则直接报错!!!

    13. 判断字符串中是否全为纯数字组成（.isdigit）

      age = '123abc456789'
age1 = '123456789'
print(age.isdigit())  # False
print(age1.isdigit())  # Ture

    14. 查找某个字符在字符串中所对应的索引位置。（.index）、（.find）。

      age = '123abc4567'
age1 = '1234567'
print(age1.find('6'))  # 索引对应 5
print(age.find('9'))  # 返回值  -1  则是没有
#如果输入没有的值.find会返回-1 表示没有。
print(age.index('6'))  # 索引对应 8
print(age1.index('9'))  # 直接报错
# 如果输入没有的值index会直接报错。

    15. 正文相关的操作

      字符串.capitalize 替换字符串首字母大写 .titl替换所有首字母大写

      res = 'my name is jason'
print(res.title())  # My Name Is Jason  改变所有字符首字母大写
print(res.capitalize())  # My name is jason  只改第一首字母大写
基本数据类型之列表

列表（list）

它可以存放多个元素并且能够很方便的将其取出来使用。

  1. 基本使用

    使用中括号括起来，内部可以输入任意类型的数据值，数据值与数据值之间用逗号分隔开来它可以存放任意数据类型，按照索引取值法来取出我们需要的数据值。

    list1 = ['name', 'age', 'like', 'reptile']
print(list1[0])  # name  根据索引取值
# 索引取值呢它是按照从0开始的顺序依次排列取出
#而且取值需要根据列表里面对应的数据值的数量来取如果超出会直接报错！

  2. 类型转换

    print(type(list(123)))  # 整型不能转换为列表 直接报错！
print(type(list(12.3)))  # 浮点型不能转换为列表 直接报错！
print(type(list('asas')))  #<class 'list'>  字符串可以被转成列表
print(type(list({'name': "jason", 'pwd': 123})) # 字典也可以被转为列表
# 能够被for循环的数据都可以转成列表

  3. 索引取值及切片取值

    list1 = ['name', 'age', 'like', 'reptile']
print(list1[0])  # name  根据索引取值
print(list1[-1])  # reptile  反向索引取值
list1 = ['name', 'age', 'like', 'reptile', '1', '2', '3', '5']
print(list1[::])  # 取列表整体
print(list1[5:])  # ['2', '3', '5']  从5号索引取列表剩余数据值
print(list1[:3])  # ['name', 'age', 'like'] 从0号索引开始取值到索引2（顾头步顾尾）
print(list1[0:3])  # ['name', 'age', 'like'] 等同于上面
print( list1[::-1]) 
# ['5', '3', '2', '1', 'reptile', 'like', 'age', 'name']

  4. 统计列表中数据值的个数 (len)

list1 = ['name', 'age', 'like', 'reptile', '1', '2', '3', '5']
print(len(list1))  # 8 统计列表整体数据值数量

  1. 列表的内置方法

    1. 将列表按顺序排列(.sort)

      dd1 = ['ss3','ss', 'ss2','s', 'sss23']
dd1.sort()  # 升序 从小到大排列
print(dd1) # ['s', 'ss', 'ss2', 'ss3', 'sss23']
dd1.sort(reverse=True)  # 降序 从大到小排
print(dd1)  # ['sss23', 'ss3', 'ss2', 'ss', 's'

    2. 统计参数里输入的元素在列表中出现的次数（.count）

      dd1 = ['ss3','ss', 'ss2','s','ss', 'sss23','ss']
print(dd1.count('ss')) # 3   
# 如果没有输出结果会显示为0 如果不输入任何参数则直接报错

    3. 根据参数来查找其对应的索引值，找到后会就不会再往下找了不管它后面还有没有只取一个。（.index）

      dd1 = ['ss3','ss', 'ss2','s', 'sss23']
print(dd1.index('ss'))  # 1
# 如果输入不存在的值则会直接报错！！！

    4. 往列表最后插入单个元素。(.append)

      dd1 = ['ss3','ss', 'ss2','s', 'sss23']
dd1.append('333')
print(dd1)  # ['ss3', 'ss', 'ss2', 's', 'sss23', '333']
# 如果是列表之类的包含很多值的则会将其整体插入进去。

    5. 往列表最后追加元素，如果是个像列表一样整体会逐步追加进去。(.extend)

      dd1 = ['ss3','ss', 'ss2','s', 'sss23']
dd1.extend(['ss', 'so'])
print(dd1)  # ['ss3', 'ss', 'ss2', 's', 'sss23', 'ss', 'so']

    6. 根据索引弹出元素，不输入索引则默认弹出最后一个元素。(.pop)

      dd1 = ['ss3', 'ss', 'ss2', 's', 'sss23', 'gggg555']
dd1.pop(0)  # 根据索引弹出数据值 
print(dd1)  #['ss', 'ss2', 's', 'sss23', 'gggg555']
# 不输入参数默认谈出最后一位

    7. 根据索引往列表里追加元素。可追加单个数据值也可追加整个列表。(insert)

      dd1 = ['ss3', 'ss', 'ss2', 's', 'sss23', 'gggg555']
dd1.insert(1,['sss','sss'])
print(dd1)  # ['ss3', ['sss', 'sss'], 'ss', 'ss2', 's', 'sss23', 'gggg555']
# 不加索引则会直接报错！！！

    8. 反转列表将列表整体倒序。(.reverse)

      dd1 = ['ss3', 'ss', 'ss2', 's', 'sss23', 'gggg555']
dd1.reverse()
print(dd1)  # ['gggg555', 'sss23', 's', 'ss2', 'ss', 'ss3']

    9. 删除整个列表所有数据值。(.clear)

      dd1 = ['ss3', 'ss', 'ss2', 's', 'sss23', 'gggg555']
dd1.clear()
print(dd1)  # dd1 = []
# 得到的是一个空列表

    10. 指定移除列表中的元素。（.remove）

      dd1 = ['ss3', 'ss', 'ss2', 's', 'sss23', 'gggg555']
dd1.remove('ss2')
print(dd1)  # ['ss3', 'ss', 's', 'sss23', 'gggg555']
基本数据类型之字典

字典（dict）

它也是可以存放多个数据值并且能够很方便的去除数据值来，它是根据K:V键值对取值的K是对应数据值的解释信息一般都是字符串类型，V是数据值。V可以使用任意类型的数据

  1. 基本使用

    用大括号括起来，内部可以存放很多个数据因为字典是无序的取值是按照K:V键值对取值，取值需要将你需要取值对应的K输入进去

    注意取值需要根据对应的K取，如果输入的是不存在的K就会直接报错！

    # 取数据值18
dict1 = {'name' ：'zidian', age : 18, }
print{dict1['age']} # 18
# 将需要的数据值取出

  2. 类型转换

print（dict（[('name','jason')('age',18)]））
print(dict(name='jason','age'=18))
#第一种是以列表套元组的方式
# 第二种是以变量名赋值操作直接定义
#字典一般很少涉及类型转换都是直接定义使用

dict1 = {
    'age':18
    'name':'jason'
    'hobby':['rade','run']
}

#字典的k是对v的描述信息一般都是字符串因为字符串 k其实只要是不可变类型都行一般都是用字符串具有对v极强的描述性


#字典内k:v键值对是无序的 取值是根据k取值的
# 取值操作
# print(info['username'])  # 不推荐使用 键不存在会直接报错
# print(info['xxx'])  # 不推荐使用 键不存在会直接报错
# print(info.get('username'))  # jason
# print(info.get('xxx'))  # None
# print(info.get('username', '键不存在返回的值 默认返回None'))  # jason
# print(info.get('xxx', '键不存在返回的值 默认返回None'))  # 键不存在返回的值 默认返回None
# print(info.get('xxx', 123))  # 123
# print(info.get('xxx'))  # None
# 3.统计字典中键值对的个数
# print(len(info))
# 4.修改数据
# info['username'] = 'jasonNB'          键存在则是修改
# print(info)
# 5.新增数据
# info['salary'] = 6                    键不存在则是新增
# print(info)  # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6}
# 6.删除数据
# 方式1
# del info['username']
# print(info)
# 方式2
# res = info.pop('username')
# print(info, res)
# 方式3
# info.popitem()  # 随机删除
# print(info)
# 7.快速获取键 值 键值对数据
# print(info.keys())  # 获取字典所有的k值 结果当成是列表即可dict_keys(['username', 'pwd', 'hobby'])
# print(info.values())  # 获取字典所有的v值 结果当成是列表即可dict_values(['jason', 123, ['read', 'run']])
# print(info.items())  # 获取字典kv键值对数据 组织成列表套元组dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])
# 8.修改字典数据   键存在则是修改  键不存在则是新增
# info.update({'username':'jason123'})
# print(info)
# info.update({'xxx':'jason123'})
# print(info)
# 9.快速构造字典  给的值默认情况下所有的键都用一个
# res = dict.fromkeys([1, 2, 3], None)
# print(res)
# new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}
# new_dict['name'] = []
# new_dict['name'].append(123)
# new_dict['pwd'].append(123)
# new_dict['hobby'].append('read')
# print(new_dict)

# res = dict.fromkeys([1, 2, 3], 234234234234234234234)
# print(id(res[1]))
# print(id(res[2]))
# print(id(res[3]))
# 10.键存在则获取键对应的值 键不存在则设置 并返回设置的新值
res = info.setdefault('username', 'jasonNB')
print(res, info)
res1 = info.setdefault('xxx', 'jasonNB')
print(res1, info)
基本数据类型之布尔值

布尔值（bool）

用来表示事物是否正确，是否合理它一共就俩个值True、False。

示例：

​ is_right = True

​ is_delete = False

其中0、None、空 、空字符串、空列表、空字典......就叫做False 也称之为假！

上面条件除外的数据都叫True 也称之为真！

基本数据类型之元组

元组（tuple）

它与列表大致相同也是可以存放多个数据，也可以根据索引很方便的取出整体或者单独的数据值。不同于列表的是它可以取但是不能修改也称之为不可变列表。

基本使用

tulpe1 = (123, 2.1 'car'[12,'name'])
基本数据类型之集合

集合（set）

运用于去重和关系运算俩种场景

去重：去除重复的数据， 关系运算：判断俩个合计之间的数据关系。

基本使用

花括号括起来，内部可以存放多个数据值，数据值与数据值之间用逗号分开。

与用户交互

输入

向计算机传递用户输入的信息

input（）接受用户输入

示例：account_number = input('请输入您的账号：')

  1. 首先接受用户输入的数据

  2. 将用户输入的数据 赋值给名字（account_number）

  3. 之后就可以通过名字来使用用户输入的数据了

    print（account_number）它接受的用户输入的数据都会转成字符串类型

输出

计算机向外界传输信息。

print（ ）打印数据，将所需要打印的数据放进小括号运行打印即可

print(35）

age = 35

print(age) 括号里可以直接放数据值也可以直接放名字

print（35，age，123） 它还可以打印多个数据或者名字俩者也可以一起放进去打印

print还有一个小功能就是换行符
如：print（123，end=''）
print( 456)

正常情况下我们不加end打印出来就是分成俩行

加上end就会把打印出来的数据列成一行

打印出来的就是123456

在底层它表示的是end=\n
有： \n, \r\n

格式化输出

在python中占位需要用到占位符如（%s、%d）

%s它可以给任意类型占位。

列如：info1 = "亲爱的%s你好！你%s月的话费是%s，余额是%s!"

print(info1 %('zhangshan', 6, 60, 102.4))

%d它只给整型占位，浮点型也能使用 但是会自动忽略掉小数点后面的数值！

info1 = "亲爱的%s你好！你%s月的话费是%s，余额是%s!"

print(info1 %(123, 6, 60, 102.4))

print（'%09d' %456）输出结果 000000456

%d中间的09代表后面输出的数值不够9位数会用0将其补全

基本运算符

数学运算符
运算符 说明 实例 结果
+ 加 10+3 13
- 减 10-3 3
* 乘 10*3 30
/ 除 10/3 3.333...
// 取整 10//3 3
% 取余 10%3 1
**（次方） 幂指数 10**3 1000
赋值运算符
赋值符号 += -= *= /= //= %= **= =
说明 加赋值 减赋值 乘赋值 除赋值 取整赋值 取余赋值 幂赋值 最基本的赋值运算
举例： X = 10 X = Y
X = X+10 X = X-10 X = X*10 X = X/3 X=X//3 X=X%3 X=X**3 Y = X
X 结果： 20 0 100 3.333... 3 1 1000
赋值操作： X += 10 X -= 10 X *= 10 X /= 3 X //= 3 X %= 3 X **= 3
X 结果： 20 0 100 3.333... 3 1 1000
逻辑运算符

逻辑运算符有and、or、not这三种运算符，它们都是配合条件一起使用的。

  • and

它链接多个条件必须都成立结果才会成立,如果链接条件的符号都是and，那么判断就非常简单了。如果有一个不成立那么后面就不需要再看了因为它的判断条件是必须都成立结果才成立,如果看见一个条件不成立那肯定这个是不成立的。

# 示例：
print(10 == 10 and 5 > 10 and True and 4 < 2)
# 输出结果：False

and如果链接的条件不是一个具体的值，那么它显示出来的结果会自动转成布尔值

如果and前面的运算得出的布尔值是True 那么and连接的条件最终的结果取决于后面的

如果后面的值是明确的数据值 那么直接返回该数据值，数据值对应的布尔值必须是True

# 示例1：
print(1 == 1 and 2 == 2)  # True
print(1 == 1 and False)  # False
print(True and 1 == 1)  # True
print(1 and 10)  # 10
print(3 < 5 and 8 and 0)  # 0
print(3 < 5 and 8 and 5 > 8)  # False

  • or

    它链接的多个条件有一个成立结果就成立。

    如果链接条件的符号都是or，那么判断也非常的简单看到有一个成立的就可以直接判断成立。

    print(10 == 10 or 5 > 10 or True or 4 < 2)
# 输出结果：True

    or链接的条件成立的那个条件不是一个具体的数据值，那么它显示出来的结果会自动转换为布尔值

    如果成立的条件是个具体的数据值那么直接返回该数据值。

    print(1 == 1 or 111)  # True
print(1 or 10 > 20)  # 1
print(10 or 100)  # 10

  • not

    它是将条件取反，用于布尔值类型True、False。

    示例：not False（取反）就是True

    not True（取反）就是False

  • and、or、not

    三者是有优先级的，如果需要混合使用那么应该用小括号将其优先级区分出来。

    示例：

    print(3 < 5 and True or 7 > 10 and 4 != 4 or 3 > 3 )
# 不合理方式
print((3 < 5 and True) or ((7 > 10 and 4 != 4) or 3 > 3 )) #合理方式
# 输出结果 True

  • and和or

    连接的多个条件在返回具体结果的时候可能是布尔值也可能是数据值，我们不需要纠结这些不管返回的是True 还是False或者数据值他们都是布尔值直接认定究竟是True或者False即可。

成员运算符

  • in

    “判断成员在不在群体之内。”

    • not in

      “判断成员不在群体之内。”

    • 示例1：

      str1 = 'beautiful'
# 列如：判断某些字符有没有在字符串里面
print('beautiful' in str1)  # True
print('beau' in str1)  # True
print('bea' in str1)  # True

      字符串在做成员运算的时候，最小单位是是单个字符，它还可以增加字符数量。

    • 示例2：

      list1 = ['beautiful', 'age', 'height', 'weight']
# 列如：判断某个数据值有没有在列表里面
print('beautiful' in list1)  # True
print('beautiful''age' in list1)  # False
print('bea' in list1)  # False

      列表在做成员运算的时候，最小运算的单位是数据值整体，不能拆分也不能合并，如上所看到的结果合并的数据值和拆分后的数据值都显示为False。

    • 示例3：

      dict1 = {'age': 18, 'height': 175, 'weight': 96}
# 列如：判断某个数据有没有在字典里面
print(18 in dict1)  # False  
print('height' in dict1)  # True
print('age' in dict1)  # True

      字典在做成员运算的时候，它是根据K来做运算的，K来参与成员运算，V默认不会暴漏在外界。

身份运算符

  • is

    判断数据值的内存地址是否一致。

  • ==

    判断数据值的内容是否一致。

  • id（）

    小知识点,使用print（id（））括号里输入名字打印可以反馈给你该名字的数据值的内存地址。

    age = 18
print(id(age))  # 140735990925504

  • 示例1：

    list1 = [123,456,789]
list2 = [123,456,789]
print(id(list1))  # 2139670758720
print(id(list2))  # 2139670757760
print(list1 is list2)  # False 判断数据值的内存地址是否相等
print(list1 == list2)  # True 只判断数据值是否相等

    可以总结为值相等的数据，内存地址不一定相等

    内存地址相等的数据，值一定相等。

  • python在针对数据量小并且常用的数据会做出些内存优化叫做小整数池。

    int1 = 15
int2 = 15
print(id(int1))  # 140735786125408
print(id(int2))  # 140735786125408

  • 有些IDE工具也会在这些方面做出更多的优化处理，比如我现在使用pyCharm软件如下就是我使用pyCharm举例：

    int1 = 99999999
int2 = 99999999
print(id(int1))  # 1388842035920
print(id(int2))  # 1388842035920

多种赋值符号

  • 链式赋值

    例如：A = 10 # 我想把10这个值再赋值给B和C

    正常方式：

    A =10

    B = A

    C = B

    链式赋值方式：A = B = C = 10 # 一行搞定，方便简洁

  • 交叉赋值

    例如：A = 10 , B = 20 # 我想把A和B的值调换一下

    正常方式：

    tem = B

    B = A

    A = tem

    交叉赋值方式：A, B = B, A # 一行搞定 方便简洁

  • 解压赋值

    赋值符号的左边至少有俩个及以上的名字才能称之为解压赋值

    列如： list1 = [25, 26, 27] # 把这三个数据值分别存给A,B,C

    正常方式：

    A = list1[0]

    B = list1[1]

    C = list1[2]

    解压赋值：

    A,B,C = list1 # 一行搞定，方便简洁。

    它有个前提是你要解压的数据值跟名字的数量需要一致多一个少一个都会报错！

    有些特别情况下需要解压的数据值有很多 而且有的数据只我们又不需要
    如下操作

    # 示例：
list1= [20, 19, 17, 16, 25, 15, 45.2]
a,b,*c,d = liast1
print（a，b，d）  # 20 19 45.2
print（c）[17, 16, 25 , 15]

    在解压赋值中会自动将剩余没有名字对应的数据值组织成列表赋值给星号后面的名字。

流程控制

流程控制之理论

它所表达的就是事物的执行流程，事物的执行流程分为三种。

  • 顺序结构

    它是按照从上往下的顺序来逐步进行的，比如有三行代码需要执行，它是先从第一行开始执行，执行完后执行第二行依次类推按照顺序执行下去。

  • 分支结构

    它是根据条件的不同来执行的。比如条件正确，执行条件正确的分支内容。条件不正确，执行不正确的分支内容

  • 顺序结构

    它是根据条件的判断绝对是否一直做某一件事

流程控制之理解知识

  1. python中使用代码的缩进量来表示代码的从属关系缩进的代码能否运行也取决于上面没有缩进的父代码使用的时候父代码的末尾需要有冒号来当结束标志。

  2. 缩进量其实没有要求，只要缩进了即可，但是为了美观一般推荐缩进四个空格，可以使用Tab键快捷缩进在pyCharmzhongTab默认是四个空格。

  3. 并不是所有的代码都可以拥有子代码的或者说分支，能够拥有子代码的如下列举几个

    if、else、elif（其中elif、else不能单独使用需要配合if等其他能够拥有分支权限的关键字使用）

  4. 同属于一个父代码的多行子代码应该保证相同的缩进量，如果代码缩进了，那就必须往上找一个缩进量比它小的代码作为父代码，这个父代码如果可以拥有子代码那么没有问题，不可以则会直接报错

  5. 相同缩进量的代码彼此之间没有主次之分都是按照顺序依次执行它们就等于是同级别的代码。

流程控制之分支结构

  • 在python中如果想要编写分支结构，那么需要使用到关键字 if

    1. 单if分支

      if 条件 ：# if后面跟上条件跳到下方空四个输入子代码

      子代码： # 条件成立则会执行子代码

      示例：

      例1：
#1.定义一个人的年龄
age = 28
# 2.判断这个人的年龄
if age < 30:  # 判断这个人的年龄是否小于30，如果成立则立即执行子代码。
    print('你的年龄小于三十岁呀！！！')  # 如果父代码判断成立，我就会立即执行。

    2. if判断之else分支

      if条件： #条件成立后执行它下方的子代码

      ​ 子代码

      else： #条件不成立时执行它的子代码

      if后面跟的判断的条件可以是一个，也可以是由逻辑运算符链接的多个

      示例：

      # 1.获取用户名和密码
name = input('name>>>:')
pwd = input('pwd>>>:')
# 2.判断用户名和密码是否正确(目前只能写死)
# if name == 'jason' and pwd == 123:  # python中不同数据类型之间无法直接做比较
if name == 'jason' and pwd == '123':  # python中不同数据类型之间无法直接做比较
	print('贵宾一位')
else:
    print('没钱滚蛋')

    3. if...elif...else分支
      if 条件1:
      条件1成立执行的子代码
      elif 条件2:
      条件1不成立 条件2成立执行的子代码
      elif 条件3:
      条件1和2都不成立 条件3成立执行的子代码
      else:
      上述所有的条件都不成立执行的子代码

      if elif else三者连用 永远只会走一个分支

      elif 和 else都不能单独使用 必须结合if

      示例：

      info1 = ['jason', 'tom', 'jack', 'rain']
name = input("please enter your user name:")

if name == info1[0]:
    print("超级管理员，%s您好！" % name)
elif name == info1[2]:
    print("业务主管，%s您好！" % name)
elif name == info1[3]:
    print("业务主管，%s您好！" % name)
elif name == info1[1]:
    print("普通管理员，%s您好！" % name)
else:
    print("普通用户，%s你好！" % name)
分支结构嵌套

  • if的嵌套使用

    在大街上看到一个漂亮的背影 上去要微信

    如果要微信成功了 则邀请她去看电影(她可能拒绝 也可能接受)

    如果接受了则继续吃饭 逛街 等待天黑!!!

    1.先定义出各种条件

     is_wechat = True
 is_movie = True
 is_agree = False
 is_xxx = True

    示例：

      if is_wechat:
        print('要微信成功了')
        if is_movie:
            print('要去看电影了 找个后排座位 视野好')
            if is_agree and True:
                print('吃饭 逛街 天黑了!!!')
            else:
                print('你个臭流氓!!!')
        else:
            print('看电影多无聊!!!')
    else:
        print('你个癞蛤蟆!!!')
循环结构之while循环

  • while循环

    while 条件： （判断条件是否成立）
    子代码（条件成立之后循环执行的子代码）

    1.首先先判断while后面的条件是否成立 如果成立则立即执行它下级的子代码。子代码执行完毕之后，会再次回到while后面的条件判断处。

    2.判断条件是否成立，如果成立则继续运行子代码，完毕后再次判断while后面的条件是否 成立。依次往复，直到条件不成立才会结束。

    """这是一个无限循环的代码，因为它的条件是个True代码中也没有设定更改条件不成立，并且还没有添加结束代码所以它会无限循环下去。"""
# 示例：
while True:   
    name = input('name>>>:')
    pwd = input('pwd>>>:')
    if name == 'jason' and pwd == '123':
        print('登录成功')
    else:
        print('用户名或密码错误')
# 可以给代码设定一个计数器        
count = 1  # 定义一个变量名把数字1绑定给他
while count < 4:  # 判断count是否小于4，条件成立运行子代码。
    print(123)  # 子代码打印123
    count += 1  # 将count的数据值+1
# 如上代码当while循环运行3次后count数据值变成4条件不成立便会结束此代码。

  • while+break

    结束循环体的方式
    1.自己添加结束条件，利用while后面的条件判断更改条件结束！
    2.在循环体代码中添加关键字强制结束。

    # break只会结束它所在的那层循环体。
# 示例：
while True:
    name = input('name>>>:')
    pwd = input('pwd>>>:')
    if name == 'jason' and pwd == '123':
        print('登录成功')
        # 强制结束
        break  # 直接结束break所在的循环体 (结束本层循环)
    else:
        print('用户名或密码错误')
    
# 验证一个break只能结束它所在那一层的循环体代码
while True:
    print('我是外层的循环')
    while True:
        print('我是内层的循环')
        break
    break

  • while+continue

    continue只会结束本层循环，它下面的同级别代码会被忽视掉，直接开始下一次循环也只影响所在的那一层循环！

    # 循环打印1到10然后，我想打印到7就跳过去。
# 示例1：
count = 1
while count < 11:
    if count == 7:
        count += 1  # 让count自增1
        continue  # 跳过本次循环 直接重新开始下一次循环
    print(count)
    count += 1
# continue只会结束本层循环，直接开始下一次循环。
# 示例2：
while True:
    print(123)
    while True:
        print(321)
        continue
    continue
# 打印结果 123、321、321、321...... while+else

  • while+else

    else跟我们学的if判断中的else一样它也可以用在while里面。

    条件不成立和循环体按照提前定义好的条件正常结束它就会执行。

    # 示例：
count = 1
while count < 11:
    print(count)
    if count == 7:
        break
    count += 1
else:
    print('循环体按照提前定义好的条件正常结束 则会执行')

  • 死循环与全局标志位

    1. 死循环
    # 示例：
count = 10
while True:
    count *= 10  # 计算死循环 不允许出现 有问题对CPU影响非常大！！！

while True:
    name = input('name>>>:')  # 有等待时间 允许出现 没有问题
    1. 全局标志位
    # 示例：
flag = True
while flag:
    print(123)
    while flag:
        print(321)
        while flag:
            print(222)
            flag = False
循环结构之for循环

while能够做到的事for都能够做到。

同样for循环能够做到的事while也能做到

但for循环的方式更加的便捷，语法结构简单，尤其是循环取值。

for循环的语法结构

for 变量名 in 可迭代对象： # 字符串、列表、字典、元组...

​ for循环体的子代码。

针对变量名的命名 如果带取值的数据有明确的指向 最好做到见名知意
列如： for name in 学习姓名名单、for addr in 地址信息
如果没有明确的指向 可以使用常见的一些字母。

  • for循环基本使用

字符串取值操作。

# 示例：
str1 = 'name'
for i in str1:  # for循环将in后面的字符串单个字符循环依次取出绑定给前面的变量名i
    print(i)  # 将for循环取出i的数据值打印出来
""" 
循环的次数是由in后面的可迭代对象来决定的，
如字符串是根据字符串的单个字符总数来决定次数。
输出结果如下
n
a
m
e
"""
  • 列表取值操作
# 示例：
list1 = ['name', 'age', 123, 18]  
for i in list1:  # for循环将in后面的列表单个数据值依次循环取出绑定给前面的变量名i
    print(i)  # 将for循环取出i的数据值打印出来
    """
    循环的次数是由in后面的可迭代对象来决定的，
    如列表是根据列表中的单个数据值的数量来决定循环次数。
    输出结果如下
    ame
    age
    123
    18
    """
  • 字典取值操作
# 示例：
ict1 = {'name': 'reptile', 'age': 25, 'hobby': 'sleep'}
for i in dict1:  # 取出来的字典k和它对应的数据值绑定给i.
    print(i)  # 循环取出的数据值，打印显示默认是k，v不会显示
"""
for循环字典取值默认的取得是字典的k，
name
age
hobby
"""
dict1 = {'name': 'reptile', 'age': 25, 'hobby': 'sleep'}
for i in dict1:  # 取出来的字典k和它对应的数据值绑定给i.
    print(dict1[i])  # i的k对应的数据值打印出来
"""
输出结果
reptile
25
sleep
"""
  • 元组取值操作
# 示例：
uple1 = ('name', 'reptile', 'age')
for i in tuple1:  # for循环元组数据与列表一致 默认都是单个数据值
    print(i)
"""
输出结果
name
reptile
age
"""

  • for+range

    range可以看成是一个能够帮助我们快速产生一个包含多个数据值的列表

# 示例1：
for i in range(5)
	print(i)  # 0 1 2 3 4
 # 如果括号内只有一个数字 那么就是从0开始到数字减一结束(顾头不顾尾 左包含右不包含)
# 示例2：
for i in range(3,10)
	print(i)  # 3 4 5 6 7 8 9 
# 括号内有两个数字 第一个是起始位置(包含) 第二个是终止位置(不含)
# 示例3：
for i in range(0,100,25)
	print(i)  # 0 25 50 75
# 括号内有三个数字 最后一个是数据的间隔数(等差数列)
""""
在python2中有两个
	range()
		直接产生一个列表 当数据量很大的时候可能会造成内存溢出(爆满)
	xrange()
		其实就是python3里面的range方法
		
在python3中只有一个
	range()
		类似于是一个工厂 什么时候要什么时候创建给你 节省内存
"""
  • for+break
# 示例 1-10  7结束
# break也能够结束所在的那一层for循环# 1-10  7结束。
for i in range(1,11):
    if i == 7:
        break
    print(i)  # 1 2 3 4 5 6
  • for+continue
# 示例 1-10  7跳过
# continue也能够结束所在的那一次for循环 直接开始下一次
for i in range(1, 11):
    if i == 7:
        continue
    print(i) # 1 2 3 4 5 6 8 9 10
  • for+else
# 示例：
for i in range(10):
    print(i)
    if i == 5:
        break
        else:
				print('嘿嘿嘿 猜猜我什么时候执行')
 # else配合for一起使用 当for循环没有被强制结束的情况下 循环体结束之后运行else子代码
posted @   瓮小辉  阅读(19)  评论(0)  编辑  收藏  举报
相关博文：
· 今日内容整理
· 今日内容整合6.21
· 基础类型与总结
· python数据类型的内置方法
· 数据类型及其内置方法、类型转换
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示