PYTHON3.8学习笔记

最新推荐文章于 2024-01-08 16:00:10 发布

NAMA知己知己

最新推荐文章于 2024-01-08 16:00:10 发布

阅读量399

点赞数

分类专栏： python 文章标签：学习 python 开发语言

本文链接：https://blog.csdn.net/qq_40112791/article/details/129358169

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

概述

1、python为解释型语言，无需编译
2、交互式：可以在提示符>>>后直接执行代码

1.内置函数

# -*- coding: utf-8 -*-
print() #输出函数
input() #输入函数
id()    #对象内存地址
type()  #对象类型
value() #对象的值
chr()   #字符编码，将ASCII转成字符
ord()   #字符编码，将字符转成ASCII
str()   #类型转换，其他类型转成字符串
int()   #类型转换，其他类型转成整数
float() #类型转换，其他类型转成浮点数
bool()  #类型转换，其他类型转成布尔值
range() #返回可迭代对象，创建整数列表
list()  #列表创建的方式之一
sorted()#对可迭代对象进行排序
dict()  #字典创建的方式之一
zip()   #参数为可迭代对象，将对象中的元素打包成元组，打包后元组前加*表示解压
tuple() #元组创建的方式之一
set()   #集合创建的方式之一

2.字符串前缀

# -*- coding: utf-8 -*-
r'\t'#让转义字符不起作用，成为普通字符
u'字符串中有中文'#Unicode编码，防止中文乱码
f'{name}'#格式化字符串
b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'#字节类型数据，用于编码解码

3.print函数

# -*- coding: utf-8 -*-
"""
print()
例如print(520),python解释器会将这段解释成计算机可以识别的。

输出内容：（1）数字（2）字符串（3）含有运算符的表达式
输出目的地：（1）显示器（2）文件
输出形式：（1）换行 （2）不换行

"""

print(530)
print(98.5)

print('hello')
print("hello")

print(3+1)

#将数据输出文件中,(1)所指定的盘符存在（2）使用file=fp
fp = open('C:/Users/lixiangqin/Desktop/python/内输出.txt','w')
#a+:如果文件不存在就创建，如果存在就在文件内容的后面追加
str = 'hello,python'
print(str,file=fp)
fp.close()
#不进行换行输出（输出内容在一行当中）
print('hello','world','python')

4.转义字符

# -*- coding: utf-8 -*-
# \ +转义功能首字母
print('hello\nworld')#n——>newline
print('hello\tworld')
print('helloooo\t world')
print('hellooooo\t world')
print('hello\rworld')#world将hello覆盖了
print('hello\bworld')#\b是退一个格，将o退没了

print('http://www.baidu.com')

print('老师说：\'大家好\'')

#原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前面加上r或R
print(r'hello\nworld')
print(r'hello\nworld\\')
#最后不能是单个\
#print(r'hello\nworld\')

5.二进制与字符编码

# -*- coding: utf-8 -*-
#acsii用了前面0~127的编码，后面的由每个国家自行使用
#中国有三代 gb
#每个国家同一个符号编号不一样，所以unicode统一符号的编码
#UTF-8规定了每个符号所占的字符数

print(chr(0b100111001011000))#0b表示二进制
print(ord('乘'))

6.保留字、标识符、变量

# -*- coding: utf-8 -*-
"""
#保留字
import keyword
print(keyword.kwlist)

"""
"""
标识符：变量、函数、类、模块和其它对象的起的名字
规则：（1）字母、数字、下划线（2）不能以数字开头（3）不能是保留字（4）是严格区分大小写的

"""

"""
变量
(1)标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
(2)类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
(3)值：表示对象所存储的具体数据，使用print(obj)来答应输出
"""
name = "玛丽亚"
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)
#当多次赋值之后，变量名会指向新的空间，玛丽亚所在的内存空间会被垃圾回收机制回收
name = "楚留冰"
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

7.数据类型

# -*- coding: utf-8 -*-
"""
常用数据类型
（1）整数类型 int
（2）浮点数类型 float
（3）布尔类型 bool
（4）字符串类型 str
"""

#1、整数可以表示为二进制、十进制、八进制、十六进制
print('十进制',118)
print('二进制',0b10101111)#二进制以0b开头
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1eaf)#十六进制以0x开头

#2、浮点数由整数部分和小数部分组成
#浮点数存储不精确性：使用浮点数进行计算式，可能会出现小数位不确定的情况（导入decimal模块可以解决）
f1 = 1.1
print(f1,type(f1))
f2 = 2.2
print(f2)
print(f1+f2)#浮点数计算结果不对，因为计算机是二进制存储的。
from decimal import Decimal

print(Decimal(f1)+Decimal(f2))#依旧是错误的结果

f3 = Decimal('1.1')
f4 = Decimal('2.2')
print(f3+f4)

print(Decimal('1.1')+Decimal('2.2'))

#3、布尔类型
b1 = True
b2 = False
print(b1,type(b1))
print(b1+1)# 1+1的结果为2 True表示1
print(b2+1)# 0+1的结果为1 False表示0

#4、字符串类型：不可变的字符序列
#可以用单引号''  双引号"" 三引号''' '''或""" """来定义
#（1）单引号和双引号定义的字符必须在一行（2）三引号定义的字符串可以分布在连续的多行

str1 = '人生苦短，我用python'
print(str1,type(str1))
str2 = "人生苦短，我用python"
print(str2,type(str2))
str3 = """人生苦短，
我用python"""
print(str3,type(str3))
str4 = '''人生苦短，
我用python'''
print(str4,type(str4))

8.数据类型转换

# -*- coding: utf-8 -*-
'''
为什么需要进行数据类型转换:将不同数据类型的数据拼接在一起
str()
int()
float()
'''
name = '张三'
age = 20

print(type(name),type(age))
print('我叫'+name+',今年,'+str(age)+'岁')

print('-----------------str()将其他类型转为str类型---------------')
a = 10
b = 98.9
c = True
print(type(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))

print('-----------------int()将其他类型转为int类型---------------')
s1 = '128'
f1 = 98.7
s2 = '76.77'
b1 = True
s3 = 'hello'
print(type(s1),type(f1),type(s2),type(b1),type(s3))
print(int(s1),type(int(s1))) #将str转为int类型，字符串为数字串
print(int(f1),type(int(f1))) #将float转为int类型，截取整数部分，舍掉小数部分
#print(int(s2),type(int(s2))) #将str转为int类型，报错，因为字符串为小数串
print(int(b1),type(int(b1))) #将bool转为int类型
#print(int(s3),type(int(s3))) #将str转为int类型，报错，字符串必须是数字串（整数），非数字不允许转换

print('-----------------float()将其他类型转为float类型---------------')
s1 = '128.98'
s2 = '76'
b1 = True
s3 = 'hello'
i = 98
print(type(s1),type(s2),type(b1),type(s3),type(i))
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(b1),type(float(b1)))
#print(float(s3),type(float(s3)))#字符串的数据如果是非数字串，则不允许转换
print(float(i),type(float(i)))

9.input函数

# -*- coding: utf-8 -*-
'''
输入函数input()
（1）作用：接受来自用户的输入
（2）返回值类型：输入值的类型为str
（3）值的存储：使用=对输入的值进行存储
'''
present = input('大圣想要什么礼物呢？')
print(present,type(present))

#从键盘录入两个整数，计算两个整数的和
# a = int(input('请输入一个加数：'))
a = input('请输入一个加数：')
a = int(a)
# b = int(input('请输入另一个加数：'))
b = input('请输入另一个加数：')
b = int(b)
#print('a+b=',int(a)+int(b))
print('a+b=',a+b)

10.运算符

# -*- coding: utf-8 -*-
"""
算数运算符
位运算符
比较运算符
布尔运算符
赋值运算符

优先级
（1）**
（2）*，/，//，%
（3）+，-
（4）<<,>>
（5）&
（6）|
（7）>,<,>=,<=,==,!=
（8）and
（9）or
（10）=
"""

'''
算数运算符：
（1）标准运算符 : 加+ 减- 乘* 除/ 整除//
（2）取余运算符：%
（3）幂运算符号：**
'''
print('---------------算数运算符-----------------')
print(1+1) #加法运算
print(1-1) #减法运算
print(2*4) #乘法运算
print(1/2) #除法运算
print(11//2) #整除运算，只取整数部分
print(11%2) #取余运算，只取余数部分
print(2**2) #幂运算，表示的是2的2次方
print(2**3) #幂运算，表示的是2的3次方

'''
'''
print(9//4) #2。向下取整
print(-9//-4) #2。向下取整
print(9//-4) #-3。注意负数的向下取整
print(-9//4) #-3。注意负数的向下取整

print(9%4) #1 余数 = 被除数 - 除数*商 9-4*2 = 1
print(-9%4) #3                     -9-(4)*(-3) = 3


'''
赋值运算符 =
（1）运算顺序从右到左
（2）支持链式赋值
（3）支持参数赋值
（4）支持系列解包赋值 a,b,c = 20,30,40
'''
print('---------------赋值运算符-----------------')
i = 3 + 4 #执行顺序从右到左
print(i)

a = b = c = 20 #链式赋值,只有一个对象，由abc三个引用指向这个对象
print(a,id(a))
print(b,id(b))
print(c,id(c))

#参数赋值
a+=30 #相当于a = a + 30
print(a)
a-=10 #相当于a=a-10
print(a)
a*=2#相当于a = a*2
print(a,type(a))
a/=3#相当于a= a/2
print(a,type(a))
a//=2#相当于a= a//2
print(a,type(a))
a%=2#相当于a = a%2
print(a,type(a))

#解包赋值,变量个数与值个数对应
a,b,c = 20,30,40
print(a,b,c)

'''
交换两个变量的值
'''
a,b = 10,20
print('交换之前：',a,b)
a,b = b,a
print('交换之后：',a,b)

'''
比较运算符
（1）> ,< , >=, <= ,!=
（2）==：对象value的比较
（3）is，is not：对象id的比较
'''
print('---------------比较运算符-----------------')
a,b = 10,20
print('a>b吗?',a>b)
print('a<b吗?',a<b)
print('a>=b吗？',a>=b)
print('a<=b吗？',a<=b)
print('a!=b吗？',a!=b)
print('a==b吗？',a==b)
'''
一个 = 称为赋值运算符，==称为比较运算符
一个变量由三部分组成，标识id，类型type，值value
==比较的是值
is,is not比较的是标识
'''
a = 10
b = 10
print(a==b) #True a与b的值相等
print(a is b) #True a与b的标识相等
print(a is not b)

lst1 = [11,22,33,44]
lst2 = [11,22,33,44]
print(lst1 == lst1) #True
print(lst1 is lst2) #False
print(lst1 is not lst2)


'''
布尔运算符
（1）and 并且
（2）or 或者
（3）not 取反,对bool类型的操作数取反
（4）in
（5）not in
'''
print('---------------布尔运算符-----------------')
a,b = 1,2
print(a == 1 and b == 2)#True,True and True——>True
print(a == 1 and b < 2)#False,True and False——>False
print(a != 1 and b == 2)#False,False and Ture——>False
print(a != 1 and b < 2)#False,False and False——>False


print(a == 1 or b == 2)#True,True and True——>True
print(a == 1 or b < 2)#False,True and False——>True
print(a != 1 or b == 2)#False,False and Ture——>True
print(a != 1 or b < 2)#False,False and False——>False

f = True
f2 = False
print(not f)
print(not f2)


s= 'helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)


'''
位运算符：将数据转成二进制计算
（1）位与 &
（2）位或 |
（3）左移运算符 <<,高位溢出，低位补零。
（4）右移运算符 >>，高位补零，低位截断
'''
print(4&8)
print(4|8)
print(4<<1)#左移1位相当于乘以2
print(4<<2)#左移2位相当于乘以4
print(4<<10)#左移10位：4096

print(4>>1)#右移1位相当于除以2
print(4>>2)#右移2位相当于除以4
print(4>>10)#右移10位：0

11.程序的组织结构

# -*- coding: utf-8 -*-
"""
顺序结构
对象的布尔值
选择结构：单分支结构if，双分支结构if else，多分支结构if elif else，嵌套if
"""
#顺序结构
'''把大象装冰箱一共分几步？'''
print('-------------程序开始-------------')
print('1、将冰箱门打开')
print('2、将大象放进冰箱')
print('3、将冰箱门关闭')
print('-------------程序结束-------------')

#对象的布尔值：Python一切皆对象，所有对象都有一个布尔值。使用内置函数bool()获取对象的布尔值
'''以下对象的布尔值为False
False
数值0
None
空字符串
空列表
空元组
空字典
空集合
'''
print('--------------以下对象的布尔值为False--------------')
print(bool(False))#False
print(bool(0),bool(0.0))#数值0
print(bool(None))#None
print(bool(''),bool(""))#空字符串
print(bool([]),bool(list()))#空列表
print(bool(()),bool(tuple()))#空元组
print(bool({}),bool(dict()))#空字典
print(bool(set()))#空集合
print('--------------其它对象的布尔值均为True---------------')
print(bool(18))
print(bool(True))
print(bool('helloworld'))
#选择结构——单分支结构 if 条件表达式
money = 1000
s = int(input("请输入取款金额")) #取款金额
#判断余额是否充足 
if money >= s :
    money -= s
    print('取款成功，余额为：',money)
#选择结构——双分支结构 if - else 条件表达式
num = int(input('请输入一个整数'))
#条件判断奇数偶数
if num%2 == 0:
    print(num,'是偶数')
else:
    print(num,'是奇数')
#选择结构——多分支结构 if elif else 条件表达式
score = int(input("请输入一个成绩："))
if score >=90 and score <=100:
    print("A级别")
elif score >=80 and score <= 89:
    print("B级别")
elif score >=70 and score <= 79:
    print("B级别")
elif score >=60 and score <= 68:
    print("D级别")
elif score >= 0 and score <=59:
    print("E级别")
else:
    print("对不起，成绩有误，不在成绩有效范围内")
    
#python支持数学表达式的写法
if 90 <= score <=100:
    print("A级别")
elif 80 <= score <= 89:
    print("B级别")
elif 70 <= score <= 79:
    print("B级别")
elif 60 <= score <= 68:
    print("D级别")
elif 0 <= score <=59:
    print("E级别")
else:
    print("对不起，成绩有误，不在成绩有效范围内")

#选择结构——嵌套if
answer = input("您是会员吗？y/n")
money = float(input("请输入您的购物金额："))
#外层判断是否是会员
if answer == 'y':
    if money >= 200:
        print("打八折，付款金额为",money*0.8)
    elif money >=100:
        print("打九折，付款金额为",money*0.9)
    else:
        print("不打折，付款金额为",money)
else:#非会员
    if money >= 200:
        print("打9.5折，付款金额为",money * 0.95)
    else:
        print("不打折，付款金额为",money)

12.条件表达式

# -*- coding: utf-8 -*-
num_1 = int(input("请输入第一个整数:"))
num_2 = int(input("请输入第二个整数："))
if num_1 >= num_2:
    print(num_1,">=",num_2)
else:
    print(num_1,"<=",num_2)
print("使用条件表达式进行比较")
#如果条件表达式为True执行右侧代码，为False执行左侧代码
print(str(num_1)+" >= "+str(num_2) if num_1 >= num_2 else str(num_1)+" <= "+str(num_2))

13.pass语句

# -*- coding: utf-8 -*-
"""
pass 用于先搭建语法结构
"""
answer = input("您是会员吗？y/n")
if answer == 'y':
    pass
else:
    pass

age = int(input("请输入您的年龄"))
if age:
    print(age)
else:
    print("您的年龄是：",age)

14.range函数

# -*- coding: utf-8 -*-
"""
内置函数range():用于生成整数序列
优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象是，才回去计算序列中的相关元素
"""
#range()三种创建方式
'''第一种创建方式，只有一个参数
'''
r = range(10)#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，默认从0开始，默认相差1为步长
print(r)
print(list(r))

'''第二种创建方式，给了两个参数
'''
r = range(1,10)#[1, 2, 3, 4, 5, 6, 7, 8, 9],指定了起始值，从1开始，到10结束（不包含10），默认相差1为步长
print(r)
print(list(r))

'''第三种创建方式，给了三个参数
'''
r = range(1,10,2)#[1, 3, 5, 7, 9]
print(r)
print(list(r))

'''判断指定的整数，在序列中是否存在 in 、not in
'''
print(10 in r)
print(9 in r)

print(10 not in r)
print(9 not in r)

15.循环结构

# -*- coding: utf-8 -*-
"""
反复做同一件事情的情况，称为循环
while 
for in
四部循环法
（1）初始化变量
（2）条件变量
（3）条件执行体（循环体）
（4）改变变量
break、continue 流程控制语句

"""
a = 1
#判断条件表达式
while a <= 10:
    #执行条件执行体
    print(a)
    a+=1

'''计算数字和'''
sum = 0    
#（1）初始化变量
a =1
#(2)条件变量
while a<=5:
    #（3）条件执行体
    sum+=a
    #（4）改变变量
    a+=1
print('和为：',sum)


'''计算偶数和'''
sum = 0
#(1)初始化变量
a = 1
#（2）条件变量
while a<=100:
    #（3）条件执行体
    if a%2 == 0:   #这里可以利用0的布尔值为False来判断 if not bool(a%2):
        sum+=a
    #（4）改变变量
    a+=1
print('和为：',sum)


for item in 'python':
    print(item)
    
for i in range(10):
    print(i)
    
#如果循环体中不需要使用到自定义变量，可以将自定义变量写为 ”_“
for _ in range(5):
    print('天下皆所用之材')
    
#使用for 循环，计算1-100之间的偶数和
sum = 0
for item in range(1,101):
    if item % 2 == 0:
        sum +=item
print(sum)

#输出100到999之间的水仙花数 举例 153 = 3**3+5**3+1**3
for item in range(100,1000):
    a = item //100
    b = item//10 %10
    c = item % 10
    #print(a,b,c)
    if a**3+b**3+c**3 == item:
        print(item ,'为水仙花数')
#流程控制语句 break
for item in range(3):
    pwd = input('请输入密码:')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

#流程控制语句 continue
for item in range(1,51):
    if item%5 == 0:
        print(item)

for item in range(1,51):
    if item%5 != 0:
        continue
    print(item)

16.else语句

# -*- coding: utf-8 -*-
"""
else 语句 不尽可以搭配if使用，还可以搭配for while使用，当时循环非正常结束时直接else
"""

for item in range(3):
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:#若循环正常结束（非break结束循环），执行此部分
    print('对不起，三次密码均输入错误')
    

a=0
while a<3:
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1
else:
    print('对不起，三次密码均输入错误')

17.嵌套循环

# -*- coding: utf-8 -*-
"""
嵌套循环
"""

for i in range(1,4):
    for j in range(1,5):
        print('*',end='\t')
    print()
    
for i in range(1,10):
    for j in range(1,i+1):
        print('*',end=(''))
    print()

for i in range(1,10):
    for j in range(1,i+1):
        print(j,'*',i,'=',i*j,end=('\t'))
    print()

18.列表

# -*- coding: utf-8 -*-
"""
列表：
列表的特点：（1）列表元素按顺序有序排序
（2）索引映射唯一98个数据，如lst[0]为hello,lst[1]为world,lst[2]为
（3）列表可以存储重复数据
（4）任意数据类型混存
（5）根据需要动态分配和回收内存
获取列表中的单个元素lst[N-1]
（1）正向索引从0到N-1
（2）逆向索引从-N到-1
（3）指定索引不存在，抛出indexError
获取列表中的多个元素：切片操作
lst[start:stop:step]
步长为正数的情况
lst[1:5:1]等同于lst[1:5]等同于lst[1:5:]，step不些默认为1
lst[:5:1]等同于lst[0,5,1],start不写默认为0
lst[1::2],stop不写默认到最后一个元素

步长为负数的情况

遍历列表

"""
#创建列表的第一种方式，使用[]
lst = ['hello','world',98]
#创建列表的第二种方式，使用内置函数list()
lst2=list(['hello','world',98])

#获取指定元素的索引，给元素找索引
lst = ['hello','world',98,'hello']
print(lst.index('hello'))
print(lst.index('hello',1,4))

#获取列表中指定的元素，给索引找元素
lst = ['hello','world',98,'hello','world',234]
print(lst[2])
print(lst[-3])

#获取列表中多个元素
lst = [10,20,30,40,50,60,70,80]
#start = 1,stop = 5,step= 1
lst2 = lst[1:6:1]
print('原列表',id(lst))
print('切的片段',id(lst2))
print('----------步长为正数----------------')
print('----------省略步长step--------------')
print(lst[1:5:1])
print(lst[1:5])
print(lst[1:5:])
print('----------省略开始位置start----------')
print(lst[0:5:1])
print(lst[:5:1])
print('----------省略结束位置stop-----------')
print(lst[1:8:1])
print(lst[1::1])
print('----------步长为负数----------------')
print(lst[::-1])
print(lst[7::-1])
print(lst[6:0:-2])


print('----------遍历列表----------------')
for item in lst:
    print(item)

19.操作列表

# -*- coding: utf-8 -*-
"""
列表元素的增删改查
增：append,extend,insert,切片
删：remove，pop，切片，clear，del
改：指定索引赋值，切片赋值

列表元素排序:sort,内置函数sorted

"""
#增加
print('----------向列表末尾添加元素append----------------')
lst = [10,20,30]
print(lst,id(lst))
lst.append(100)
print(lst,id(lst))
print('----------向列表末尾添加至少添加一个元素extend----------------')
lst2= ['hello','world']
#lst.append(lst2)
lst.extend(lst2)
print(lst)
print('----------向列表的任意位置添加一个元素insert----------------')
lst.insert(1, 9)
print(lst)

print('----------切片列表并添加元素----------------')
lst3 = [True,False,'hello']
#lst[1:]=lst3 只指定了start
lst[1:3]=lst3 #指定了start和stop
print(lst)

#删除
lst = [10,20,30,40,50,60,70,80,90,10]
print('----------使用remove移除,指定元素-----------')
print('''一次删除一个元素
      重复元素只删除第一个
      元素不存在抛出ValueError
      ''')
lst.remove(10)
print(lst)
#lst.remove(1)


print('----------使用pop移除,指定索引-----------')
print('''一次删除一个元素
      索引不存在抛出IndexError
      不指定参数（索引），则删除列表最后一个元素
      ''')
lst.pop(1)
print(lst)
lst.pop()
print(lst)

print('----------使用切片操作，删除至少一个元素，将产生一个新的列表对象-----------')
new_lst = lst[1:3]
print(lst)
print(new_lst)

print('----------clear,清空列表元素-----------')
print(lst)
lst.clear()
print(lst)

print('----------del，删除列表对象-----------')
del lst
#print(lst)

#修改

lst = [10,20,30,40]
#一次修改一个值
lst[2] = 100
print(lst)
lst[1:3]=[300,400,500,600]
print(lst)



#排序
lst = [20,40,10,98,54]
print(id(lst),lst)
lst.sort()#未指定参数，默认升序排序
print(id(lst),lst)
lst.sort(reverse=True)
print(id(lst),lst)

new_lst = sorted(lst)
print(id(lst),lst)
print(id(new_lst),new_lst)
new_lst = sorted(lst,reverse=True)
print(id(lst),lst)
print(id(new_lst),new_lst)

20.列表生成式

# -*- coding: utf-8 -*-
"""

列表生成式
[i*i for i in range(1,10)]
i*i:表示列表元素的表达式
i：自定义变量
range(1,10):可迭代对象

"""

lst = [i for i in range(1,10)]
print(lst)
lst = [i*i for i in range(1,10)]
print(lst)    

lst2 =[i*2 for i in range(1,6)]
print(lst2)

21.字典

# -*- coding: utf-8 -*-
"""
字典：{}，内部存储键值对，无序序列
字典名={a:b,c：d,o:q}
a,c,o为键key
b,d,q为值value
字典的实现原理：字典的实现原理与查字典类似，查字典是先根据部首或拼音查找对应的页码，Python中的字典是根据key查找value所在的值。
因此key必须是不可变序列，hash(key)得出来的值也才能是不变的。
不可变序列：字符串，整数
可变序列：列表，字典



获取字典中的元素
字典名[键]
字典名.get(键)


key的判断 in not in

字典的增删改

获取字典视图
keys()
values()
items()


字典元素的遍历
for i in dict

字典的特点：
（1）字典中的所有元素都是一个key-value对，key不允许重复，value可以重复。key重复的话会存在只覆盖的情况
（2）字典中的元素是无序的。无序是指不可排序，存在哪块就是那块
（3）字典中的key必须是不可变对象。
（4）字典也可以根据需要动态的伸缩
（5）字典会浪费较大的内存，是一种使用空间换时间的数据结构

"""
'''创建字典'''
#使用花括号创建
scores = {'张三':100,'李四':98,'王五':90}
print(scores,type(scores))
#使用内置函数dict()
info = dict(name = 'jack',age = 18)
print(info,type(info))
#空字典
d = {}
print(d,type(d))

'''获取字典中的元素'''
'''
(1)使用[获取]
键不存在会报错：keyError
'''
print(scores['张三'])
#print(scores['赵五'])#报错：keyError
'''
(2)使用get方法获取
键不存在会显示None
如果指定了默认值，键不存在显示默认值
'''
print(scores.get('张三'))
print(scores.get('赵五'))#None
print(scores.get('赵五',99))#键不存在，显示默认值99


'''key的判断'''
print('张三' in scores)
print('张三' not in scores)

'''删除指定的键值对'''
del scores['张三']
print(scores)
'''清空字典'''
scores.clear()
print(scores)

'''新增字典元素'''
scores['陈六'] = 56
print(scores)

'''修改字典元素'''
scores['陈六'] = 100
print(scores)


'''
获取字典视图的三个方法
(1)keys()获取字典中所有key
(2)values()获取字典中所有value
(3)items()获取字典中所有key,value对
'''
scores = {'张三':100,'李四':98,'王五':90}
scores_key = scores.keys()
print(scores_key,type(scores_key))
lst = list(scores_key)#将所有的key组成的视图转成列表
print(lst,type(lst))

scores_value = scores.values()
print(scores_value,type(scores_value))
lst2 = list(scores_value)
print(lst2,type(lst2))

item = scores.items()
print(item,type(item))
lst3 = list(item)#转换之后的列表元素由元组组成
print(lst3,type(lst3))




'''
字典元素的遍历
'''

for item in scores:
    print(item,scores[item],scores.get(item))


d = {'name':'张三','name':'李四'}
print(d)

22.字典生成式

# -*- coding: utf-8 -*-
"""

字典生成式
{item.upper():price for item,price in zip(items,prices)}

"""

items = ['apple','peal','watermenlon']
prices = [98,100,89,20]
dic = {item:price for item,price in zip(items,prices)}#以元素少的部分为基准生成
print(dic)
dic2 = {item.upper():price for item,price in zip(items,prices)}
print(dic2)

23.元组

# -*- coding: utf-8 -*-
"""

元组：python内置的数据结构之一，是一个不可变序列
不可变序列与可变序列
（1）不可变序列：字符串、整数、元组，没有增删改的操作
（2）可变序列：列表、字典，可以对序列执行增删改操作，对象地址不发生更改


元组的创建方式
（1）使用()
（2）使用内置函数tuple()



为什么要将元组设计成不可变序列
（1）在多任务环境下，同时操作对象时不需要加锁
（2）因此，在程序中尽量使用不可变序列
注意事项：元组中存储的是对象的引用
a)如果元组中对象本身是不可变对象，则不能再引用其他对象
b)如果元组中的对象是可变对象，则可变对象的引用不允许更改,但数据可以改变

知道有多少元素的情况下可以使用索引
元组的遍历：元组是可迭代对象，可以使用 for in 遍历

"""

#第一种创建方式，使用（）
t = ('python','world',98)
print(t,type(t))

t2 = 'python','world',98#省略了小括号
print(t2,type(t2))

t3 = ('python',)#当元组中只有一个元素时，需要加上逗号
print(t3,type(t3))

#第二种创建方式，使用内置函数tuple()
t1 = tuple(('python','world',98))
print(t1,type(t1))

'''空元组'''
#复习，空列表
l1 = []
l2 = list()
#复习，空字典
d1 = {}
d2 = dict()
#空元组
t4 = ()
t5 = tuple()




t = (10,[20,30],40)
print(t,type(t))
print(t[0],id(t[0]))
print(t[1],id(t[1]))
print(t[2],id(t[2]))

'''尝试t[1]修改为100'''
#t[1] = 100#'tuple' object does not support item assignment
'''由于[20.30]是列表，而列表是可变序列，所以可以将列表中添加元素，而列表的内存地址不变'''
t[1].append(100)
print(t,type(t))
print(t[0],id(t[0]))
print(t[1],id(t[1]))
print(t[2],id(t[2]))




#元组的遍历
for item in t:
    print(item)

24.集合

# -*- coding: utf-8 -*-
"""

集合：
（1）python语言提供的内置数据结构
（2）与列表、字典一样都属于可变类型的序列
（3）集合是没有value的字典
（4）无序序列,元素不能重复

创建方式{}
内置函数set()



集合的相关操作
(1)集合元素的判断操作 in或 not in
(2)集合元素的新增操作： add()或update()
(3)集合元素的删除操作：remove()，删除指定元素，指定元素不存在抛出keyerror
                    discard()，删除指定元素，指定元素不存在不抛异常
                    pop()，删除任意元素
                    clear(),清空集合

"""

'''第一种创建方式{}'''
s = {1,2,3,5,6,5,7,5,9,8}
print(s,type(s))#集合中重复的元素去掉了
'''第二种创建方式内置函数set()'''
s1= set(range(6))
print(s1,type(s1))

s2 = set([1,2,3,4,5,6,2])#列表转集合,同时去掉了重复元素
print(s2,type(s2))

s3 = set((1,1,2,3,4,5,64))#元组转集合
print(s3,type(s3))

s4 = set('python')
print(s4,type(s4))

s5 = set({3,5,6,3,1})
print(s5,type(s5))

#空集合,不可以使用{}，已经被字典先用掉了
s6 = set()
print(s6,type(s6))

'''集合的相关操作'''
s= {10,100,200,3,6,9}
'''集合元素的判断操作'''
print(10 in s)
print(20 in s)
print(20 not in s)

'''集合元素的新增操作'''
s.add(80)
print(s)
s.update({200,300,500})
print(s)
s.update([4,1,2,3])
print(s)
s.update((23,76,98))
print(s)

'''集合元素的删除操作'''
s.remove(100)
print(s)
#s.remove(30)#KeyError: 30
s.discard(30)#不抛异常
print(s)

s.pop()
print(s)
s.pop()
print(s)
#s.pop(20)#TypeError: pop() takes no arguments (1 given),pop是无参数的

s.clear()
print(s)

25.集合之间的关系

# -*- coding: utf-8 -*-
"""
集合间的关系
（1）两个集合是否相等：运算符==或！=进行判断
（2）一个集合是否是另一个集合的子集:issubset(),B是A的子集
（3）一个集合是否是另一个集合的超集：issuperset()，A是B的超集
（4）两个集合是否没有交集：isdisjoint()

"""
'''两个集合是否相等：元素相同，集合就相等'''
s = {10,20,30,40}
s2 = {30,40,20,10}
print(s==s2)
print(s!=s2)

'''一个集合是否是另一个集合的子集'''
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))


'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2))
print(s1.issuperset(s3))

'''两个集合是否没有交集'''
print(s2.isdisjoint(s3))#False 有交集为False
s4 = {100,200,300}
print(s2.isdisjoint(s4))#True 无交集为True

26.集合之间的数据操作

# -*- coding: utf-8 -*-
"""

集合的数学操作
（1）两个集合的交集intersection，&
（2）两个集合的并集union |
（3）两个集合的差集difference -
（4）两个集合的对称差集

"""

'''交集'''
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print(s1.intersection(s2))#A∩B
print(s1 & s2)
'''并集'''
print(s1.union(s2)) #A+B
print(s1 | s2)

'''差集'''
print(s1.difference(s2))#A - A∩B
print(s1 - s2)

'''对称差集'''
print(s1.symmetric_difference(s2)) #A+B - A∩B
print(s1^s2)

27.字符串的驻留机制

# -*- coding: utf-8 -*-
"""

字符串的驻留机制：只保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而把该字符串的地址付给新创建的变量。

驻留机制的几种情况（交互模式）
（1）字符串的长度为0或1时
（2）符合标识符的字符串
（3）字符串只在编译时进行驻留，而非运行时
（4）[-5,256]之间的整数数字
sys中的intern方法强制2个字符串指向同一个对象
pycharm,anaconda等对字符串进行了优化处理

字符串驻留机制的优缺点
（1）当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串时会比较影响性能的
（2）需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率比要比“+”效率高


"""

a = 'Python'
b = "Python"
c = '''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))

#注：以下内容应当看交互式下的运行结果
'''（1）字符串的长度为0或1时'''
s1 = ''
s2 = ''
print(s1 is s2)

s1 = '%'
s2 = '%'
print(s1 is s2)

'''（2）符合标识符的字符串'''
s1 = 'abcd'
s2 = 'abcd'
print(s1 is s2)

s1 = 'abc%'
s2 = 'abc%'
print(s1 is s2)#交互式下是False

'''（3）字符串只在编译时进行驻留，而非运行时'''
a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab','c'])#运行时调用join方法
print(a is b)
print(a is c)#False

'''（4）[-5,256]之间的整数数字'''

a = -5
b = -5
print(a is b)
a = -6
b = -6
print(a is b)#交互式下是False

'''sys中的intern方法强制2个字符串指向同一个对象'''
s1 = 'abc%'
s2 = 'abc%'
print(s1 is s2)#交互式下是False
import sys
s1 = sys.intern(s2)
print(s1 is s2)#交互式下是True

28.字符串的常用操作方法

# -*- coding: utf-8 -*-
"""


字符串的查询操作方法：
index 查找字符串第一次出现的位置，找不到抛出ValueError,
rindex 查找字符串最后一次出现的位置，找不到抛出ValueError。
find 查找字符串第一次出现的位置，找不到返回-1，
rfind 查找字符串最后一次出现的位置，找不到抛出-1。


字符串的大小写转换
upper() 把所有字符都转成大写字母
lower() 把所有字符都转成小写字母
swapcase() 把字符串中所有大写字母转成小写字母，把所有小写字母转成大写字母
capitalize() 把第一个字符转换为大写，把其余字符转换为小写
title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写

字符串内容对齐操作的方法
center() 居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
ljust() 左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
rjust() 右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
zfill() 右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度喜爱与等于字符串的长度，返回字符串本身

字符串的劈分
split() a)从字符串的左边开始劈分，默认的劈分字符是空字符串，返回的值都是一个列表。
        b)以通过参数sep指定劈分字符串的是劈分符
        c)通过参数maxsplit指定劈分字符串时最大的劈分次数，在经过最大劈分次数之后，剩余的字串会单独作为一部分
rsplit  a)从字符串的右边开始劈分，默认的劈分字符是空字符串，返回的值都是一个列表。
        b)以通过参数sep指定劈分字符串的是劈分符
        c)通过参数maxsplit指定劈分字符串时最大的劈分次数，在经过最大劈分次数之后，剩余的字串会单独作为一部分


判断字符串的方法
isidentifier() 判断指定的字符串是不是合法的标识符（字母、数字、下划线、中文）
isspace()      判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
isalpha()      判断指定的字符串是否全部由字母组成
isdecimal()    判断指定的字符串是否全部由十进制的数字组成
isnumeric()    判断指定的字符串是否全部由数字组成
isalnum()      判断指定字符串是否全部由字母和数字组成



字符串操作的其他方法
replace()    字符串替换，第一个参数指定被替换的字串，第二个参数指定替换字串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第三个参数指定最大替换次数
join()       字符串的合并，将列表或元组中的字符串合并成一个字符串


"""
'''字符串的查找'''

s = 'hello,hello'

print(s.index('lo'))#3
print(s.find('lo'))#3
print(s.rindex('lo'))#9
print(s.rfind('lo'))#9

#print(s.index('k'))#ValueError
print(s.find('k'))#-1

#print(s.rindex('k'))#ValueError
print(s.rfind('k'))#-1

'''字符串的大小写转换'''
s = 'hello,python'

a = s.upper()#转成大写之后换产生新的字符串对象
print(a,id(a))
print(s,id(s))

b = s.lower()
print(b,id(b))#转换为小写后产生新的字符串对象
print(s,id(s))
print(b==s)
print(b is s)

s2 = 'hello,Python'
c = s2.swapcase()
print(c,id(c))

d = s2.capitalize()
print(d,id(d))

e = s2.title()
print(e,id(e))


'''字符串对齐操作'''
s = 'hello,python'
'''中心对齐'''
print(s.center(20,'*'))
'''左对齐'''
print(s.ljust(20,'*'))
print(s.ljust(10))#指定长度小于实际长度，返回原字符
print(s.ljust(20))#填充空格
'''右对齐'''
print(s.rjust(20,'*'))
print(s.rjust(10))
print(s.rjust(20))

'''右对齐，使用0进行填充'''
print(s.zfill(20))
print(s.zfill(10))

print('-8910'.zfill(8))#添加到-号之后



'''字符串的劈分'''
s = 'hello world python'

#'''从左侧开始劈分'''
print(s.split())
'''指定劈分符'''
s1 = 'hello|world|python'
print(s1.split(sep='|'))
'''指定最大劈分次数'''
print(s1.split(sep='|',maxsplit=1))

#'''从右侧开始劈分'''
print(s.rsplit())
print(s1.rsplit(sep='|'))
print(s1.rsplit(sep='|',maxsplit=1))



'''字符串的判断'''

'''是否合法标识符'''
print('1.','hellp.python'.isidentifier())
print('2.','hello'.isidentifier())
print('3.','张三'.isidentifier())
print('4.','张三_'.isidentifier())
print('5.','张三_123'.isidentifier())

'''判断是否由空字符串'''
print('6.','\t'.isspace())

'''判断是否全部由字母组成'''
print('7.','abc'.isalpha())
print('8.','张三'.isalpha())#True
print('9.','张三1'.isalpha())

'''判断是否全部由由十进制数字'''
print('10.','1234'.isdecimal())
print('11.','123四'.isdecimal())
print('12.','ⅠⅡⅢ'.isdecimal())

'''是否全部由数字组成'''
print('13.','1234'.isnumeric())
print('14.','123四'.isnumeric())#True
print('15.','ⅠⅡⅢ'.isnumeric())#True
      
'''是否全部由数字和字母组成'''      
print('16','abc1'.isalnum())
print('17','张三123'.isalnum())#True
print('18','abc!'.isalnum())#False


'''字符串的替换'''
s = 'hello,python'
print(s.replace('python', 'java'))

s = 'hello,python,python,python'
print(s.replace('python', 'java',2))


'''字符串的合并'''
lst = ['hello','join','python']
print('|'.join(lst))
print(''.join(lst))

t = ('hello','java','python')
print(''.join(t))


print('*'.join('python'))#将python作为字符串序列，可迭代对象

29.字符串的比较操作

# -*- coding: utf-8 -*-
"""

字符串的比较操作
（1）运算符：>,>=,<,<=,==,!=
（2）比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等是，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
（3）比较原理：两个字符进行比较时，比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr是指定ordinal value 可以得到其对应的字符

"""

print('apple'>'app')#True
print('apple'>'banana')#False
print(ord('a'),ord('b'))
print(chr(97),chr(98))

print(ord('唐'),ord('伯'),ord('虎'))


'''== 与is的区别
==比较的是value
is比较的是id
'''
a=b='python'
c = 'python'
print(a==b)
print(a==c)
print(a is b)
print(a is c)

30.字符串的切片操作

# -*- coding: utf-8 -*-
"""


字符串的切片操作
字符串是不可变类型
（1）不具备增、删、改等操作
（2）切片操作将产生新的对象


"""
s = 'hello,python'
s1 = s[:5]
print(s1)
s2 = s[6:]
print(s2)
s3 = '!'
new_str = s1+s3+s2
print(new_str)

print('---------------切片[start,stop,step]---------------------')
print(s[1:5:1])
print(s[::2])

print(s[::-1])#nohtyp,olleh
print(s[-6::1])#python

31.格式化字符串

# -*- coding: utf-8 -*-
"""

字符串拼接浪费内存空间，但是比如证明文件这些，具有相应的格式

格式化字符串的两种方式
（1）%作占位符
（2）{}作占位符

"""

name = '张三'
age = 20
#使用%占位符
print('我叫%s,今年%d岁'%(name,age)) #元组

#使用{}占位符
print('我叫{0},今年{1}岁'.format(name, age))#format方法，0，1代表的是占位符的顺序

#使用f-string
print(f'我叫{name},今年{age}岁')#f格式化,PYTHON3.0以上新增



#精度和宽度
print('%10d' % 99) #10表示宽度
print('%f' % 3.141592654)#进位了
print('%.3f' % 3.141592654)#保留小数点后三位

print('%10.3f' % 3.141592654)#一共总宽度为10，保留小数点后3位
print('hellohello')


print('{0}'.format(3.141592654))#0表示占位符的顺序

print('{0:.3}'.format(3.141592654))#.3表示一共三位数
print('{0:10.3}'.format(3.141592654))#.3表示一共三位数
print('{0:.3}'.format(13.141592654))#.3表示一共三位数
print('{0:10.3}'.format(13.141592654))#.3表示一共三位数


print('{0:.3f}'.format(3.141592654))#.3表示保留小数点后3位

32.字符串的编码转换

# -*- coding: utf-8 -*-
"""


字符串的编码转换
（1）为什么需要字符串的编码转换
A计算机：str在内存中以Unicode表示
A计算机编码，通过byte字节传输
B计算机解码byte字节并显示在屏幕上
（2）编码与解码的方式
编码：将字符串转换为二进制数据(bytes)
解码：将bytes类型的数据转换成字符串类型


"""

#编码
s = '天涯共此时'
print(s.encode(encoding='GBK'))#在GBK这种编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8'))#在UTF-8这种编码格式中，一个中文占三个字节

#解码
byte = s.encode(encoding='GBK')
print(b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'.decode(encoding='GBK'))
print(byte.decode(encoding='GBK'))

print(b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'.decode(encoding='UTF-8'))