Python编程知识

最新推荐文章于 2022-08-04 11:54:27 发布

君卿陌路

最新推荐文章于 2022-08-04 11:54:27 发布

阅读量465

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/Rosire/article/details/89856230

版权

Python 专栏收录该内容

4 篇文章 1 订阅

订阅专栏

初始编码(理论)
电脑的传输和储存实际上都是二进制的方式
ascii码设计之初是为7位(2**7=128种可能)，预留一位，总共是8位（只包括字母，数字，特殊字符）；ascii码最左边那一位全为0 (设计者设计之初是为了预留一位方便以后拓展)；ascii码总共位256位。
8位bit(二进制) == 1byte(一个字节，如一个字母)
1024byte(字节) == 1kb
1024kb == 1MB
1024MB == 1GB
1024GB == 1TB
万国码——Unicode
最开始设计：
1个字节表示所有的英文，特殊字符，数字等
2个字节(16位二进制)表示一个中文 (中文共有9万多字)
4个字节(32位二进制)表示一个中文
升级版的utf-8：3个字节(24位二进制)表示一个中文
gbk中只包含中英文，仅仅中国使用，2个字节表示一个中文
运算符
算术运算、比较运算、赋值运算、
a) 逻辑运算优先级为：() > not > and > or

print(3 > 4 or 4 < 3 and 1 == 1)  # 返回值为F
print(1 < 2 and 3 < 4 or 1 > 2)  # 返回值为T
print(2 > 1 and 3 < 4 or 4> 5 and 2 < 1)  # 返回值为T
print(1 > 2 and 3 < 4 or 4 > 5 and 9 < 8)  # 返回值为F
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  # 返回值为F
print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  # 返回值为F

x or y为非零的数，若x为真，无论y为何值，返回结果均为x；若x为零(或为假)，则返回值为y。
x and y均为真的非零数，则返回值为y; 若x, y中存在零，则返回值为0；若x, y一真一假，则返回值为真的值 ( x and y与x or y的返回值相反 )。
b) str与bool之间的转换
非空字符串的返回结果都是True
仅仅是空字符的转换才会输出False，如，
print(bool(’’)) # 返回结果为False

s = ""
if s:
    print('nothing, please enter again')  # 无任何值返回
else:
    pass

在这里插入图片描述
c) int与bool之间的转换
非零的数字转换为bool值，结果即为真(True)；
零转换为bool值，结果即为假(False)；
int转换为bool值，一次只能填一个数。
只有两种True对应1，False对应0。如下

print(int(True))  # bool转换为int
print(int(False))

print(bool(2))  # int转换为bool
print(bool(-2))  # bool括号的数字只能为一个数字
print(bool(0))

在这里插入图片描述

# 考虑优先级
print(2 or 100 or 2 or 4)  # 返回值为2
print(0 or 4 and 3 or 2)  # 返回值为3
print(1 > 2 and 3 or 4 and 3 < 2)  # 返回值为False

print(5 < 4 or 3)  # 返回结果为真的结果，即结果为3
print(2 > 1 or 6)  # 返回值为True
print(3 and 2 > 1)  # 返回值为True
print(3 < 1 and 0)  # 返回值为False

d) if并列语句
计算1-2+3-4+5……+99除88外的总和。
在这里插入图片描述
#用户登陆（三次机会）且每次输出错误时显示剩余错误次数（提示：使用字符串格式化）

username = 'Rose'
password = '123456'
i = 3
while i > 0:
    user = input('please enter your account:')
    i -= 1
    if user == username:
        word = input('please enter your password:')
        if word == password:
            print('verify successfully, logging.')
            print('''Congratulations,
            welcome to come in!
            Account: %s
            Password: %s
            '''%(user,word))
            break
        else:
            if i == 0:
                print("Your haven't the chance to try! Game is over." )
                answer = input('Try again? Y or N')
                if answer == 'Y':
                    i = 3
            print('The password is incorrect, please enter again.')
            print('You have '+str(i)+' chance')
    else:
        print("please enter correct username!")
        if i == 0:
            print("Your haven't the chance to try.")
            answer = input('Try again? Y or N')
            if answer == 'Y':
                i == 3
        print('You have '+str(i)+' chance')
else:
    print('No changce to try')

e) int转换为str

i = 1
s = str(i)
str(int())
f) str转换为int (转换的内容必须为数字)
s = ‘123’
i = int(s)
int(str())

复习

int

i = 3  # 转换为二进制 0000 0011
print(i.bit_length())  # 把数字i转换为二进制最少的位数

bool: True Flase
str: bool(str(’’)) 内容为空的字符串返回bool值为False

s = 'alexsb'
s1 = s[1]
s2 = s[1:3]
s3 = s[0:]
s4 = s[:]  # 返回值为所有信息
s5 = s[0:-1]  # 返回值为a~s元素（顾头不顾尾）
s6 = s[0:3:2]  # 取值为a和e
s7 = s[2::-2]  # 取值e和a

的格式按顺序，添加索引，用变量定义
for i in 可迭代对象：
Pass

list(列表)
列表里面的元素用逗号隔开
索引
增删改查嵌套
增加
.append 增加到列表里的元素最后

l = ['Alex','Bob','Tracy','Cindy',[1,2,3],'Fanny']
l.append('Rose')
print(l)  # 因为元素是增加到列表里面的，所以应该打印列表
# 循环一直增加，可以按Q退出，回来之后还能持续增加
while l:
    name = input('Plse enter information:')
    if name.upper().strip() == 'Q':
        break
    else:
        l.append(name)
        print(l)
print(l)

插入

l = ['Alex','Bob','Tracy','Cindy',[1,2,3],'Fanny']
l.insert(3,'女神')  # 指定索引位置插入insert
print(l)
l.extend('人生')  # 迭代插入，int对象不能用于迭代插入
l.extend([1,2,3])  # 插入的是每个组成的元素，且添加到列表的最后
print(l)

按索引删除

l = ['Alex','Bob','Tracy','Cindy',[1,2,3],'Fanny']
l.pop()  # 默认删除最后一个
print(l)
l.pop(0)  # 指定索引位置删除pop，制定删除Alex
l = ['Alex','Bob','Tracy','Cindy',[1,2,3],'Fanny']
l.remove([1,2,3])  # 按照元素删除
print(l)
l.clear()  # 清空
del l  # 删除一整个列表
del l[0:2]  # 选择性删除列表元素

改

l[0] = '改'  # 按照索引位置逐个修改元素
l[0:2] = '人生如此'  # 切片拆分替换元素（所有改新的元素都会拆分）

查询

for i in l:
    print(i)  # 查询列表中的每个元素
print(l[0:2])  # 切片查询列表中的元素

print(len(l))  # 列表中所有元素个数
print(l.count('Alex'))  # 列表中元素Alex存在几个
print(l.index('Fanny'))  # 找某个元素的索引位置

排序

字符串也可排序，字符串是根据第一个字符的ascii码去排序

l = [1,5,3,8,4,6,7]
l.sort()  # 默认正序排序
print(l)
l.sort(reverse = True)  # 倒序排序
print(l)
l.reverse()  # 反转排序
print(l)

列表的嵌套

s = ['Alex','Fanny','bob','Tracy',['Kitty','Alice',22],88]
print(s[1][0])  # 查询字母F
# 查询并修改元素后放回
name = s[2].capitalize()  # 将b改为大写B
print(name)
s[2] = name  # 将Bob返回原位
print(s)
s[1] = 'Rose'  # 找到Fanny并替换掉
print(s)
s[0] = s[0].replace('A','B')  # 替换元素的里面部分内容
print(s)
s[4][0] = s[4][0].upper()  # 将Kitty都大写并返回原位
print(s)

元组
只读列表，可循环查询，可切片，不能修改,常用于元组的拆包；
元组里面有列表的话，则列表里面的字符串元素可更改。

tu = (1,2,3,'alex',[4,5,6,'score'],'ege')
print(tu[3])
print(tu[0:4])
for i in tu:
    print(i)
tu[4][3] = tu[4][3].upper()
print(tu)
tu[4].append('rose')
print(tu)

join
可迭代对象可以放字符串，列表，元组，集合等(int和bool除外)。

s = 'eges'
s1 = '_'.join(s)
s2 = '-'.join(s)
print(s1)
print(s2)

# join（list -> str）
l = ['Alex','Fanny','bob','Tracy','Kitty','Alice']
s = '+++'.join(l)
print(s)  # 返回值是字符串
# split (str -> list)

# range有序列表，即[0，1，2，3，4，……]数字范围 (顾头不顾尾）
for i in range(0,10):
    print(i)
for i in range(0,10,2):
    print(i)
for i in range(10,0,-2):
    print(i)
for i in range(0,10,-1):  # 程序不执行也不报错
    print(i)

# 用for语句打印元组元素
s = ['Alex','Fanny','bob','Tracy',['Kitty','Alice',22],88]
for i in s:
    if type(i) == list:
        for k in i:
            print(k)
    else:
        print(i)

字典(dict)
字典是python中唯一一个映射类型
数据类型划分：可变数据类型，不可变数据类型
不可变数据类型：元组(tuple)，bool值，int，str
可变数据类型：列表(list)，字典(dict)，集合(set)
dict的key必须是不可变数据类型，value必须是任意数据类型。
特点：二分查找查询，存储大量关系型数据，无序的。

#格式如下
dic = {
    'name':['Alex','Bob'],
    'py':[{'PY5':22,'age':18},
          {'PY6':23,'age':19},
          {'PY7':24,'age':20},
          ],
    True:1,
    (1,2,3):'Fanny',
    2:'Alice',
}
print(dic)

dict的增加

dic1 = {'age':18,'name':'Jim','hobby':'swim'}
dic1['high'] = 185  # 没有key值对，增加
dic1['age'] = 22  # 如果有key，则值覆盖，增改
dic1 = {'age':18,'name':'Jim','hobby':'swim'}
dic1.setdefault('weight',48)  # 无key值，则增加
dic1.setdefault('name','Kitty')  # 有key值，则不作改变
print(dic1)

dict的删除

dic1 = {'age':18,'name':'Jim','hobby':'swim'}
dic1.pop('age')  # 有返回值，按key删除
print(dic1)
dic1 = {'age':18,'name':'Jim','hobby':'swim'}
print(dic1.pop('Hi','no key'))  # 若无key，不执行也不报错,可设置返回值None,
print(dic1.pop('Hi',None))  # None是一个特殊的数据类型，不是字符串

dic = {'age':18,'name':'Jim','hobby':'swim'}
dic.popitem()  # py3.6以上版本，默认从最后一个key值开始删除(随即删除)
print(dic)
dic = {'age':18,'name':'Jim','hobby':'swim'}
dic.clear()  # 清空dic
del dic
print(dic)

改

dic = {'age':18,'name':'Jim','hobby':'swim'}
dic2 = {'age':'Ginny','Weight':75}
dic2.update(dic) # 把dic的key值对update到dic2里面
print(dic)
print(dic2)

查

dic = {'age':18,'name':'Jim','hobby':'swim'}
print(dic.keys(),type(dic.keys()))  # 返回列表，内容为key
print(dic.values())  # 列表，key值
print(dic.items())  #列表，内容为元组，元组里面是key值
for i in dic:  # 返回值是key
    print(i)
for i in dic.keys():  # 等同于for i in dic:
    print(i)
for i in dic.values():  # 返回值是value
    print(i)
a,b = [1.2],[3,4]
print(a,b)
for k,v in dic.items():  # 返回值是三个具有key和value的元组
    print(k,v)

dic = {'age':18,'name':'Jim','hobby':'swim'}
V1 = dic.get('name1')  # 查询gert(key,None)
print(V1)

字典的嵌套

dic = {
    'name':['Alex','Bob'],
    'py':{'PY5':22,
          'PY6':23,
          'PY7':24,
          },
    True:1,
    'user':'Alice'
}
dic['user'] = 'Rose'  # 改value
dic['name'].append('Kitty')  # 添加元素
dic['name'][1] = dic['name'][1].upper()  # 让Bob改为全大写
dic['py']['PY8'] = 25  # 给py添加key and value，"PY8:25"
print(dic)

# 习题：判断int型数据有几个
info = input('>>>')  # qwert123qer4dfg21
for i in info:
    if i.isalpha():
        info = info.replace(i,' ')
l = info.split()
print(len(l))

习题：
输出商品列表，用户输入序号，显示用户选中的上品
商品l = [‘手机’,‘电脑’,‘鼠标垫’,‘游艇’]
要求：1：页面显示序号 + 商品名称，如：
1.手机
2.电脑
……
2：用户输入选择的商品序号，然后打印商品名称
3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
4：用户输入Q或者q，退出程序。

flag = True  # flag也可用数字1代替，但是1不如flg灵活，flag标志位方便随时改变条件
while flag:
    l = ['手机','电脑','鼠标垫','游艇','键盘']
    for i in l:
        print('{}\t{}'.format(l.index(i)+1,i)) # 索引从0开始，应该+1；返回值为商品的排序
    num_of_choice = input('please enter the num of choice/enter q or Q:')  # 先全部输出商品，即现完成循环语句，因而此代码不留空
    if num_of_choice.isdigit():
        num_of_choice = int(num_of_choice)
        if num_of_choice > 0 and num_of_choice <= len(l):  # len(i)可方便添加商品列举索引，如添加5 键盘
            print(l[num_of_choice-1])
        else:
            print('please enter available num:')
    elif num_of_choice.upper == 'q':
        break
    else:
        print('please enter num:')

小数据池
py2和py3通用的内容如下：
数字的范围是-5 – 256，在这个范围内的数据，相同的赋值共用一个数据池；
含有特殊字符的字符串不会共用地址，s20还是同一地址，超过s20则各用地址。
除int和str之外的数据类型不存在小数据池。
各个编码之间的二进制是不能互相识别的，会产生乱码。
文件的存储和传输不能是 unicode-32 二进制，只能是ascii，utf-8等二进制(unicode占用的空间太多)。

i1 = 6
i2 = 6
print(id(i1),id(i2))  # i1和i2返回的地址均为140721323795248，若i1，i2的值超过范围则地址位不同

py3的特点：
str在内存中是用unicode编码方式存储的，传输过程之前会先转化为其他的编码方式；
bytes类型是一种特殊的数据类型，与str类似，但是内存编码与str不一样，可直接传输。
英文：
str：表现形式：s = ‘alex’
编码方式：010101010 unicode
bytes: 表现形式：byt = b’alex’
编码方式：010101010 ascii，utf-8等
中文：
str：表现形式：s = ‘中国’
编码方式：010101010 unicode
bytes：表现形式：s = b’x\e91\e91\e01\e21\e31\e32’ # utf-8编码
编码方式：000101010 utf-8，gbk……

s = 'alex'
byt = b'alex'
print(s, type(s))  # 返回值为alex <class 'str'>
print(byt,type(byt))  # 返回值为b'alex' <class 'bytes'>

s = '中国'
print(s, type(s))
byt = b'中国'
print(byt,type(byt))  # 返回结果会报错

# encode编码，如何将str转换为bytes,但实际内容一样
s1 = 'alice'
s11 = s1.encode('gbk')
print(s11)  # 打印返回值为b'alice'
s2 = '中国'
s22 = s2.encode('gbk')
s21 = s2.encode('utf-8')
print(s22)  # 打印返回值为b'\xd6\xd0\xb9\xfa'
print(s21)  # 打印返回值为b'\xe4\xb8\xad\xe5\x9b\xbd'

集合
集合是无序的，不重复的数据集合；它里面的元素必须是不可变类型，但是集合本身是可变的数据类型。{ }

set1 = set({1,2,3})  # 返回值为{1, 2, 3}
set2 = {1,2,3,[2,3],{'name':'alex'}}  # 元素含可变数据类型，返回结果报错
print(set1)
print(set2)

增(返回值是随机的无序的)

set1 = {'Alex','Fanny','Ege','Bob'}
set1.add('增加')  # 增加，返回值随机的可能为{'Ege', '增加', 'Alex', 'Fanny', 'Bob'}
print(set1)
set1.update('无序增加')  # 返回值为{'Bob', 'Alex', '增', '增加', 'Fanny', 'Ege', '无', '序', '加'}
print(set1)

删(返回值是随机的无序的)

set1 = {'Alex','Fanny','Ege','Bob'}
set1.pop()
print(set1)  # 返回值是随机的无序的{'增加', 'Alex', 'Fanny', '增', '无', '加', '序', 'Bob'}
set1.remove('Alex') # 按元素删除
print(set1)  # 返回值为{'Bob', 'Fanny', 'Ege'}
set1.clear()
print(set1)  # 返回值为set()
del set1
print(set1)  # 报错

查(只有如下一种方法，且返回值是无序)

set1 = {'Alex','Fanny','Ege','Bob'}
for i in set1:
    print(i)

交集(& or intersection)

set1 = {'Alex','Fanny','Ege','Bob'}
set2 = {'Alex',2,3,'Ege'}
print(set1 & set2)  # 返回值为{'Alex', 'Ege'}
print(set1.intersection(set2))  # 返回值为{'Alex', 'Ege'}

并集(\ or union)

set1 = {'Alex','Fanny','Ege','Bob'}
set2 = {'Alex',2,3,'Ege'}
print(set1 | set2)  # 返回值{2, 3, 'Ege', 'Bob', 'Fanny', 'Alex'}
print(set1.union(set2))

反交集(^ or symmetric_difference)

set1 = {'Alex','Fanny','Ege','Bob'}
set2 = {'Alex',2,3,'Ege'}
print(set1 ^ set2)  # 返回值为{2, 3, 'Fanny', 'Bob'}
print(set1.symmetric_difference(set2))

差集(- or difference)

set1 = {'Alex','Fanny','Ege','Bob'}
set2 = {'Alex',2,3,'Ege'}
print(set1 - set2)  # 返回值为{'Fanny', 'Bob'}
print(set1.difference(set2))

自己或超集

set1 = {'Alex','Fanny','Ege','Bob'}
set2 = {'Alex',2,3,'Ege'}
set3 = {2,3}
print(set3 < set2)  # True，若set3的元素都包含在set2，返回值为True，否则为False
print(set3.issubset(set1))  # False

去重

li = [1,2,33,3,44,44,5,55,55,6,666,666]
set1 = set(li)
print(set1)  # 返回值为集合{1, 2, 3, 33, 5, 6, 44, 55, 666}
li = list(set1)
print(li)  # 返回值为列表[1, 2, 3, 33, 5, 6, 44, 55, 666]

frozenset可变集合，让集合变成不可变类型

s = frozenset('welcome')
print(s,type(s))  # 返回值为frozenset({'w', 'c', 'o', 'e', 'l', 'm'}) <class 'frozenset'>
for i in s:
    print(i)

其他（for, enumerate, range）

for 循环

用户按照顺序循环可迭代对象的内容

msg = '2022年北京申奥成功了！'
for item in msg:
    print(item)
li = ['北京','天安门','故宫','天坛']
for i in li:
    print(i)
dic = {'name':'Alex','age':22,'heigt':175}
for k,v in dic.items():
    print(k,v)

enumerate(枚举)

对于一个可迭代的(iterable) / 可遍历的对象(如列表，字符串)，enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['北京','天安门','故宫','天坛']
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in numerate(li,100):  # 起始位置默认是0，可更改
    print(index,name)

range

指定范围，生成指定数字

for i in range(1,10):
    print(i)  # 返回值为打印列举数字1，2，3，4，5，6，7，8，9
for i in range(1,10,2):
    print(i)
for i in range(10,1,-2):
    print(i)