关于后端:python基础一

Python 简介

我是一种跨平台计算机程序设计语言
我是一种解释性语言 -> 开发过程中没有编译这个环节, 这一点我与 java 不一样
我是一种交互式语言 -> 你能够在我的提示符 >>> 间接执行代码
我是面对对象语言 -> 在我的世界里所有皆对象
我是初学者最好的语言 -> 对于高级程序员而言, 我十分平凡的;

转义字符

1. 就是反斜杠 + 想要实现本义性能首字母. 当字符串中蕴含反斜杠, 单引号和双银行等有特殊字符用处的字符是, 必须应用反斜杠对这些字符进行本义:

   1. 反斜杠 \\
   2. 单引号 \’
   3. 双引号 \”

2. 当字符串中蕴含换行回车, 程度制表符或退格等无奈间接示意的特殊字符时, 也能够应用转义字符当字符串:

   1. 换行 \n
   2. 回的 \r(return 光标挪动到本行的结尾, 也就是后面的字符会隐没)
   3. 程度制表符 \t
   4. 退格 \b(往前删除一个字符)
   5. 空 \0
   6. 换页 \f
   7. 八进制数 \0dd 如：\012 标识换行

   8. 十六进制数 \xhh：\x0a 代表换行
      在字符串后面加 R 或者 r 标识，代表前面的字符串将忽视本义进行输入

      print('holle\nword')
      print('holle  word')
      print('holle\tword')
      print('holle\bword')
      print('holle\rword')

二进制与字符编码

• 计算机为什么可能意识我?
• 他只意识 0 和 1 基本不意识我, 晚期的程序员爸爸为了让计算机可能意识我将我可能意识的符号和数字对应好, 而后做成一张表叫 ASCLL 表, 通知计算器某种符号你应该是用那个整数示意:A 应用了 8 个未知能力装得下我, 在计算机其他们叫一个字节
• 8bit->1byte
• 1024byte->1kb
• 1024kb->1mb
• 1024mb->1gb
• 1024gb->1Tb
  print(chr(0b1001111001011000))
  print(ord(‘ 乘 ’))
  后果
  鹘
  20056

数据类型

• 罕用的数据类型: 不可变的

  • 整数类型:int->98, 英文为:integer 简写为 int 能够示意负数, 正数和零, 整数的不同进制示意形式:

    • 十进制 -> 默认的进制形式
    • 二进制 -> 以 0b 结尾
    • 八进制 -> 以 0o 结尾
    • 十六进制 ->0x 结尾
  • 浮点数类型:float->2.112

  • 布尔类型:bool->True,False, 用来示意真或假的值,True 真,False 假, 布尔能够转化为整数

    • True->1
    • False->0
      以下规定都是 False
• False 或者 None
• 数值中的零，包含 0，0.0 虚数 0
• 空序列，包含字符串，空元组，空列表，空字典

• 自定义对象的实例，该对象的__bool__办法返回 False 或者__len__返回 0

  • 字符串类型:str->’hello word’, 字符串被称为不可变的字符序列

    • 能够应用单引号 ” 双引号 ”” 三引号 ””” 或 ”’ 来定义
    • 单引号和双引号的字符串必须在一行

    • 三引号定义的字符串能够散布在间断的多行

      out = 'my name is  yanchenglong'
      out2 = '''my name is 
      yanchenglong'''
      print (out)
      print (out2)
      #my name is  yanchenglong
      # my name is
      # yanchenglong
      

• 浮点类型

  • 浮点数整数局部和小数局部组成
  • 浮点数存储不精准性

  • 应用浮点数进行计算时, 可能会呈现小数位数不确定的状况

    print(1.1+2.2) #3.3000000000000003
    # 解决方案 导入 decimal
    from decimal import Decimal
    print(Decimal('1.1')+Decimal('2.2'))# 3.3
    

数据类型转换

为什么须要数据类型转换?- 无效解决不同类型数据据拼接在一起解决的问题;

data = '1.2'
# print(int(data))# invalid literal for int() with base 10: '1.2'
data = '12'
print(int(data))
print(int(1.6))

Python 保留字

python 有一些单子赋予了特定的意义, 这些代词在你任何对想起名字的时候都不能用

**[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’,
‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]**

命名规定

1. 字母, 数字, 下划线
2. 不能以数字结尾
3. 不能是保留字
4. 严格辨别大小写

import keyword
print(keyword.kwlist)

python 中的正文

正文, 在代码对代码的性能进行解释阐明的标注性文字, 能够进步代码的可读性
正文的内容会被 python 解释器疏忽
通过包含三种类型的正文
单行正文 -> 以# 结尾晓得换行完结
多行正文 -> 并没有独自的多行正文, 将一个对三引号之间的代码成为多行正文
中文编码申明正文 -> 在文件结尾加上中文生命注解, 用指定源码文件编码格局 -> # coding:gbk

Python 的输出函数

输出函数根本应用
present=input(‘ 大圣想要什么礼物呢?’)
作用: 承受来自用户的输出
返回值类型: 输出值的类型为 str
值的存储: 应用 = 对输出的值进行存储

value = input('请输出第一个数值')
value2 = input ('请输出第二个数值')
print(type(value))
print(int(value)+int(value2))

输入函数

1. 能够输入数字, 浮点如 print(123)
2. 能够输入字符串 print(‘123’)
3. 能够输入含有运算符的表达式如 print(1+2)

其中 #号是正文

输入地位

1. 显示器 print(1)

2. 文件

   # 参数一, 文件地址. 参数二: 文件的创立, 已读写的形式关上文件, 如果文件不存在则进行创立, 如果存在则接着前面追加,print 在打印时应用 file= 文件对象
    holle = open(r'C:\Users\sj176\Desktop\holleWord.txt', 'a+')
    print('holleWord', file=holle)
    holle.close()
   

输入模式

1. 换行
2. 不换行

python 中的运算符

1. 算数运算符: 加减乘除 +-/ 取整 // 取余 % 幕运算*

2. 赋值运算符: 执行程序: 右 -> 左

   1. 反对链式赋值:a=b=c=10
   2. 反对参数复制:+=,-=,/=,//=,%=
   3. 反对系列解包复制:a,b,c=10,20,30

3. 比拟运算符: 比拟值的后果是 bool 类型, 对表达式的后果进行大小虚实等比拟:>,<,==,>=,<=,!=

   1. 对象比拟 ==
   2. 对象的 id 比拟:is ,is not

4. 布尔运算符:

   1. and 当两个运算后果 true 时运算后果才会 true
   2. or 只有一个运算符为 true 时后果才会 true
   3. not 如果运算符为 true 返回后果为 false, 如果运算符为 false 后果为 true
   4. in 在不在这个当中
   5. not in 不在这里当中

5. 位运算符: 运算二进制的数据

   1. 位与 & -> 对应位数都是 1, 后果位数才是 1, 否则为 0
   2. 位或 | -> 对应位数都是 0, 后果位数才是 0 否则为 1
   3. 左移位运算符 -> 相当于 *2, 高位溢出舍去, 低位补 0
   4. 右移位运算符 -> 相当于 /2, 低位溢出舍去, 高位补 0

运算符的优先级

**
*,/,//,%
+,-
<<<,>>>
&
|
>,<,>=,<=,==,!=
and
or
=


""" 一个 = 称为赋值运算符,== 称为比拟运算符
一个变量由三局部组成:id name value  应用 id()函数能够看到该变量的 id
== 比拟的就是 value
is,not is 比拟的时 id
"""
a,b=10,10
list1=[1,2,3]
list2=[1,2,3]
print(a==b)
print(a is b)
print(list1==list2)
print(list1 is list2)
# True
# True
# True
# False

对象的布尔值

python 所有皆对象, 所有对象都有一个 bool 值, 获取对象的布尔值 bool()函数即可
以下对象的布尔值为 False

1. False
2. 数值 0
3. None
4. 空字符串
5. 空列表
6. 空元组
7. 空字典

8. 空集合
   除了这些剩下的都是 True

   分支语句

   分支语句

   score=int(input('pass input int score'))
   if 90<=score<=100:
    print('a')
   elif 80<=score<=89:
    print('b')
   elif 70<=score<=79:
    print('c')
   elif 60<=score<=69:
    print('d')
   elif 0<=score<=59:
    print('e')
   else :
    print('sorry you score error')
   

   条件表达式

num_a = int(input('pass input number_a int'))
num_b = int(input('pass input number_b int'))
# if num_a >= num_b:
#     print(num_a, '>=', num_b)
# else:
#     print(num_a, '<', num_b)
# 如果为 True 执行右边的如果为 False 执行左边的
print(str(num_a)+'>='+str(num_b) if num_a > num_b else str(num_a)+'<'+str(num_b))

pass 语句

语句什么都不做, 只是一个占位符, 用在语法上须要语句的中央

vip = input('is you vip')
if vip == 'y':
    print('1123')
else:
    pass

range 函数

range()函数, 用于生成一个整数序列, 创立 rage 对象的三种形式

r = range(10)
# print(r) print:range(0, 10)
print(list(r))

r = range(2, 10)
# print(r) print:range(0, 10)
print(list(r))

r = range(1, 10, 2)
# print(r) print:range(0, 10)
print(list(r))
# print---
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]

• 返回值是一个迭代对象
• range 类型的有点?: 不论 range 对象示意的整数序列有多长, 所有 range 对象占用的内存空间都是雷同的, 应为仅仅须要存储 start stop 和 step, 只有当用到 range 对象是, 才会去计算序列中的相干元素
• in 与 not in 判断整数序列中是否存在 (不存在) 指定的整数

循环构造

• 重复做同一件事的状况, 称为循环

• 循环的分类

  • while
  • for -in

• 语法结构

  while 条件表达式
    条件执行体(循环体)

  抉择构造的 if 与循环构造 while 的区别

• if 是判断一次, 条件为 True 执行一行
• while 是判断 N + 1 次, 条件为 True 执行 N 次

四部循环发

1. 初始化变量
2. 条件判断
3. 条件执行体
4. 扭转变量

while 循环的执行流程

a = 1
i = 0
while a <= 90:
print('a<10', a)
if not bool(a % 2):
i += a
a += 1
print('sum', i)

for-in 循环

• in 表白从 (字符串, 序列等) 中顺次取值, 又称为遍历

• for-in 遍历的对象必须是可迭代对象

  for-in 的语法结构
  for 自定义的变量 in 可迭代对象:
  循环体

  for item in 'python':
    print(item)
    pass
  # p
  # y
  # t
  # h
  # o
  # n
  for item in range(10):
  print(item)
  pass
  
  # 0
  # 1
  # 2
  # 3
  # 4
  # 5
  # 6
  # 7
  # 8
  # 9
  for _ in range(10):
  print('hello word')
  pass
  
  # 应用 for 循环, 计算 1 到 100 之间的偶数和
  sum = 0
  for item in range(1,101):
  if item % 2 == 0:
    sum += item
    pass
  pass
  print(sum)
  
  # 失去 100-1000 的水仙花数
  for item in range(100,1000):
  ge=item%10 #失去个位数
  shi=item//10%10# 的带十位数
  bai=item//100 #失去百位数
  print(ge,shi,bai)
  if ge**3+shi**3+bai**3==item:
    print(item)

循环体内不须要拜访自定义变量, 能够将自定义变量代替为下划线

流程管制语句

break 语句, 用于完结循环构造, 通常与分支语句 if 一起应用

for item in range(3):
    pwd = input('input')
    if pwd == '1111':
        print('yes')
        break
    else:
        print('no')
        pass
    pass

a = 0
while a < 3:
    pwd = input('input:')
    if pwd == '4444':
        print('yes')
        break
    else:
        print('no')
        pass
    a += 1
    pass

continue 语句 <br/>
用户完结以后循环, 进入下一次循环, 通常用于分支语句中的 if 一起应用

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

else 语句 <br/>
与 else 语句配合应用的三种状况

if...else
while...else
for...else

test

for item in range(3):
    pwd = input('input')
    if pwd == '1111':
        print('yes')
        break
    else:
        print('no')
        pass
else:
    print('sorry 3 password error')


a = 0
while a < 3:
  a += 1
  pwd = input('input')
  if pwd == '1111':
    print('password yes')
    break
  else:
    print('password no')

else:
  print('3 error')
  pass

嵌套循环
循环构造中又嵌套了另外的残缺循环构造, 其中内存循环作为外城循环的循环体执行
99 乘法表

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

二重循环中的 break 和 continue

for i in range(5):
    for j in range(1, 11):
        if j % 2 == 0:
            # break
            continue
        print(j, end='\t')
        pass
    print()
    pass

列表

1. 变量能够存储一个元素, 而列表是一个 ’ 大容器 ’ 能够存储 N 多个元素, 程序能够不便地对这些数据进行整体操作
2. 列表相当于其余语言中的数组

lst = [1, ’23’, 1.1]
列表须要应用中括号 [] 元素之间应用英文的都好进行分隔

列表的创立形式
应用中括号
调用内置函数 list()

ls=list([1,2,'12'])
print(ls)

ls=[1,2,'12']
print(ls)

列表特点

1. 列表元素按程序有序排序
2. 索引映射惟一数据
3. 列表能够存储反复数据
4. 任意数据类型混存
5. 依据须要动态分配和回收内存

列表的查问操作

1. 获取列表的索引: 如果列表中存在 N 个雷同元素, 只返回雷同元素中的第一个元素的索引
2. 如果查问的元素列表中不存在, 则会抛出 ValueError
3. 还能够指定的 start 和 stop 之间进行查找

获取列表中的单个元素

1. 正向索引 0 到 N -1
2. 逆向索引从 - N 到 -1
3. 指定索引不存在, 抛出 IndexError

获取列表中的多个元素
列表名[start:stop:step]

1. 切片的后果 -> 源列表片段的拷贝
2. 切片的范畴 ->[start,stop]
3. step 默认为 1 -> 简写为[start,stop]
4. step 为负数 ->[:stop:step]切片的抵押给元素默认是列表的第一个元素 - 从 start 开始往后计算切片,[start::step] 切片到最初一个元素, 默认是列表的最初一个元素,- 从 start 开始往后计算切片

5. step 为正数:[:stop:step]-> 切换的第一个元素默认是列表的最初一个元素, 从 start 开始计算切片,[start::step]切片的最初一个元素默认是列表第一个元素, 从 start 开始计算切片

   lst=[10,20,30,40,50,60,70,80,90,100]
   lst2=lst[1:6:1]
   print(id(lst))
   print(id(lst2))
   print(lst[1:6:])
   print(lst[1:6:2])
   print(lst[:6:2])
   print(lst[1::2])
   print(lst[::-1])
   print(lst[6::-1])
   print(lst[6:0:-2])

   列表元素的查问操作

6. 判断指定元素在列表中是否存在
   元素 in 列表名, 元素 not in 列表名
7. 列表元素的便当
   for 迭代变量 in 列表名:
   操作

  msg = 'holle word'
lst = [1,2,3,4,5,6]
print('1' in lst)
for item in lst:
  print(item)

列表元素的增删改操作

1. 减少操作:

   1. append()在开端减少一个元素;
   2. extend()在列表开端至多增加多个元素;
   3. insert()在任意地位插入元素, 参数 1 写 index 参数 2 写想要增加的元素,

   4. 切片: 在列表的任意地位增加至多一个元素

      lst=[1,2,3,4,5]
      lst.append([1,2,3,4])
      print(lst)
      lst.extend([1,2,3,4])
      print(lst)
      lst3=[True,False]
      lst[3:]= lst3
      print(lst)

2. 列表元素删除的操作

   1. remove()一次删除一个元素, 反复元素只删除第一个, 元素不存在抛出 valueError
   2. pop()删除一个指定索引地位上的元素, 指定索引不存在抛出 IndexError, 不指定索引, 删除列表中最初一个元素
   3. 切片: 产生新的对象, 或者在改对象上进行切片赋值
   4. clear()清空列表
   5. del 删除列表对象

lst=[1,2,3,4,5,2]
lst.pop(1)
print(lst)
# lst.pop(8)
lst.pop()
print(lst)

newlist=lst[1:2]
print(newlist)
# 不产生新的对象, 执行切片删除
lst[1:3]=[]
print(lst)
# 革除列表中所有元素
lst.clear()
# del lst 将对象删除
del lst
print(lst)

删除某一个值
del lst[1]

列表批改操作

1. 批改一个值: 应用赋值
2. 批改多个值: 应用切片

lst=[1,2,3,4,5,2]
lst[2]=100 # 批改一个值
print(lst)
lst[1:3]=[300,500,1000,1,2] # 批改多个值
print(lst)

列表元素的排序

1. sort()办法在原对象进行批改
2. sorted()内置办法, 会产生一个新对象,reverse=True 指定是否是顺叙;

lst=[1,2,3,4,5,2]
print('排序前的列表',lst,id(lst))
lst.sort()
print('排序后的列表',lst,id(lst))

# 指定参数后, 能够将列表顺叙排序 reverse=True,reverse=False 就是升序排序
lst.sort(reverse=True)
print(lst)
print('----------------')
# 应用内置 sorted()
lst=[1,2,3,4,5,2]
newLst=sorted(lst,reverse=True)
print(newLst,id(newLst))
print(lst,id(lst))

其中还有：sort（key=str.lower,reverse=True)排序时不辨别大小写
列表生成式
语法格局 [i*i for i in range(10)]
i* i 示意列表元素的表达式,i 自定义变量 range(10) 可迭代对象

字典

python 内置的数据结构之一, 与列表一样是一个可变序列
以键值对的存储数据, 字典是一个无序的序列
字典的实现原理与查字典相似, 查字典是先依据部首或拼音查找对应的页面,Python 中的字典是依据 key 查找 value 所在位置;

1. 字典的创立

   1. 应用花括号{}{‘ 张三 ’:100,’ 王五 ’:10}
   2. 内置函数 dict()dict(zhangsna=100, 雷轰 =11)

2. 从字典中获取数据

   1. []取值

   2. get()取值

      data={'张三':100,'王五':10}
      ww=data['王五']# 如果获取不到则会报错 KyeError
      print(ww)
      print(data.get('张三'))# 如果不存在则会 None
      print(data.get('张 1',88))# 如果不存在则展现 88 设置的默认值

      还能够这样：

      price = [12000, 30, 220000, 10000, 8888]
      sale=[x for x in price if x>=5000]
      print(price)
      print(sale)

      二维列表

      arr=[]
      for i in range(4):
       arr.append([])
       for j in range(5):
        arr[i].append(j)
      
      print(arr)

      输入

      [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

      上述列表能够应用推导式来实现：arr=[[j for j in range(5)] for i in range(4)]

3. 字典的罕用操作

   data={'张三':100,'王五':10}
   print('wangwu' in data)
   print('wangwu' not in data)
   del data['王五']# 删除王五字段, 如果是 data 则会删除 data 字典, 如果是字典外面的内容则会删除指定的内容
   data.clear()# 将字典所有元素清空
   print(data)
   #新增
   data['djij']=1000
   print(data)
   #批改
   data['djij']=10
   print(data)

4. 字典视图

   1. keys 获取所有 key
   2. values 获取所有 value

   3. item 获取所有的 key 和 value 的键值对

      data={'张三':100,'王五':10}
      keyss=data.keys()
      print(keyss,type(keyss))
      print(list(keyss))# 将所有的 keys 转换成列表
      values=data.values()
      print(values,type(values))
      print(list(values))
      # 获取所有的键值对
      items=data.items()
      print(items,type(items))
      print(list(items))# 是由元组组成的
      

5. 遍历字典

   data={'张三':100,'王五':10}
   for item in data:
    print(item)
    print(data[item])

6. 字典生成式

   items=['a','B','C','D','E','F','G']
   pr=[10,20,30,5,1,2]
   d={item.upper():pr  for item,pr in zip(items,pr)}
   print(d) #将 key 转换成大写 upper(), 如果 key 和 value 的长度不统一则会取最短的进行复制压缩
   

7. 字典的特点

   1. key 不容许反复,value 能够反复
   2. 字典中的元素是无序的
   3. 字典中的 key 必须是不可变对象
   4. 字典也是能够依据须要动静的伸缩

   5. 字典会节约较大的内存空间, 是一种空间换工夫的数据结构

      元组

      Python 内置的数据后果之一, 是一个不可变序列
      不可变序列与可变序列

8. 不可变序列: 字符串, 元组

   1. 不可变序列: 没有增三改的操作

9. 可变序列: 列表, 字典

   1. 可变序列: 能够对序列执行增删改操作, 对象地址不产生更改

10. 为什么要将元组设计成不可变序列?

    1. 在多任务环境下, 同时操作对象是不须要加锁
    2. 因而, 在程序中尽量应用不可变序列

    3. 注意事项:

       1. 元组中存储的时对象援用, 如果元组中对象自身不可变对象, 则不能再援用其余其余对象

       2. 如果元组中的对象时可变对象, 则可变对象的援用不容许扭转, 但数据能够扭转

          s='shoee'
          print(id(s)) #2090536342704
          s+='ddd'
          print(id(s)) #2090536344752

11. 元组的创立形式

    1. t=(‘1′,’2’)

    2. tuple(())

       t=(1,2,'3') # 这个括号能够省略不写(), 如果元组只有一个 元素时, 须要在前面加上, 号
       print(t,type(t))
       dd=tuple((1,2,3,'4'))
       print(dd)
       t='2',
       print(t)
       # 空的创立
       lst=[]
       lst1=lst()
       
       d={}
       d1=dict()
       
       t=()
       t=tuple()
       

12. 元组遍历

    t=(1,2,3,4,5,6,'1')
    print(t[1])
    print(len(t)) # len 获取元组列表等长度的内置函数
    for item in t:
     print(item)

    汇合

    python 语言提供的内置数据结构
    与列表, 字典都一样属于可变类型的序列
    汇合没有 value 的字典

13. 汇合的创立形式

    1. 间接应用{}

    2. 内置函数 set

       s={'1',2,3,4,5,'2','1'}
       print(s)# 不容许反复
       s1=set(range(6))
       print(s1,type(s1))
       s3=set((1,2,3,4,1,65))
       print(s3,type(s3))
       s4=set('python')
       print(s4,type(s4))
       s5=set({12,4,12,'1'})
       print(s5,type(s5))
       s6=set({1,2,3,4,1,2,3})
       print(s6,type(s6))
       s7={}
       s8=set()
       print(s7,type(s7))
       print(s8,type(s8))

14. 汇合元素的判断操作

    1. in 或 not in

15. 汇合元素的新增操作

    1. 调用 add()办法, 一次增加一个元素
    2. 调用 update()办法至多增加一个元

16. 汇合元素的删除操作

    1. 调用 remove()办法, 一次删除一个指定的元素, 如果指定的元素不存在抛出 KyeERRPR 谬误
    2. discard()办法, 一次删除一个指定元素, 如果指定的元素不存在不抛出异样
    3. 调用 pop 办法, 一次删除要给任意元素
    4. clear()办法, 清空集合

17. 汇合之间的关系

    1. 两个汇合是否相等, 能够用运算符 == 或!= 进行判断

    2. 一个联合是否是另一个汇合的子集

       1. 能够调用办法 issubset 进行判断
       2. B 是 A 的子集

    3. 一个汇合是否是两一个汇合的超集, 父级

       1. 能够调用办法 issuperset 出项判断
       2. a 是 b 的超集

    4. 两个汇合是否没有交加

       1. 能够调用办法 isdisjoint 进行判断

18. 汇合的数学操作

    1. 交加
    2. 并集
    3. 差集

    4. 对称差集

       s1={10,20,30,40,50,60}
       s2={10,20,30,40,1}
       # 交加
       print(s1.intersection(s2))
       print(s1 & s2)
       # 并集操作
       print(s1.union(s2))
       print(s1 | s2)
       # 差集操作
       print(s1.difference(s2))
       print(s1-s2)
       # 对称差值
       print(s1.symmetric_difference(s2))
       print(s1 ^ s2)

19. 汇合生成式

    1. {i*i for i in range(1,100)}
    2. 将 {} 批改为 [] 就是列表生成式

    3. 元组没有生成式

       lst={i*i for i in range(1,7)}
       print(lst)

       数据结构	是否可变	是否反复	是否有序	定义符号
       列表(list)	可变	可反复	有序	[]
       元组(tuple)	不可变	可反复	有序	()
       字典(dict)	可变	key 不反复,value 能够反复	无序	{key:value}
       汇合(set))	可变	不可反复	无序	{}

       字符串罕用操作

20. 字符串的驻留机制

    1. 在 python 中字符串是根本数据类型, 是一个不可变字符序列
    2. 进保留一份雷同且不变字符串的办法, 不同的值被寄存在字符串的驻留池中,python 的驻留机制对雷同的字符串只保留一份拷贝, 后续创立雷同字符串时, 不会开拓新的控件, 而是把字符串的地址赋给新创建的变量

    3. 驻留机制的几种清空

       1. 字符串长度为 0 或者 1 时
       2. 合乎标识符的字符串如 abc%
       3. 字符串只在编译时驻留, 而非运行时
       4. [-5,256]整数也是驻留的
    4. sys 中 intern 办法轻质 2 个字符执行同一个对象
    5. PyCharm 对字符串进行了优化解决

    6. 字符串驻留机制的优缺点

       1. 当须要值雷同的字符串时, 能够间接从字符串池中拿来应用, 防止频繁的创立和销毁, 提声效率和节约内存, 因而字符串拼接和批改字符串时比拟影响性能的.
       2. 在须要进行字符串拼接时倡议应用 str 类型的 join 办法, 而非 + 因为 join()办法是先计算出所有字符产的长度, 而后再拷贝, 只 new 一次对象, 效率要比 + 效率高

21. 字符串的罕用操作

    1. index(): 查找字符串 substr 第一次呈现的地位, 如果查找的字符串不存在时, 抛出 ValueError
    2. reindex(): 查找 substr 最初一次呈现的地位如果查找不到则会抛出 ValueRError
    3. find()查找字符串 substr 第一次呈现的地位, 如果查找不到则会返回 -1
    4. rfind()查找字符串 substr 最初一次呈现的地位, 如果查找不到则会返回 -1
    5. upper()把字符串所有字符都转换成大写字母, 留神转换之后会产生一个新对象, 不论内容是否统一
    6. lower(), 把字符串中所有字符都转换成小写
    7. swapcase()把字符串中所有大写字母转换成小写, 把小写字母都转换成大写字母
    8. capitlize()把第一个字符转换成大写, 把其余字符转换成小写
    9. title()把每个单词的第一个字符转换成大写, 把每隔单词的残余找媳妇转换成小写
    10. center()剧中对其, 第一个参数指定宽度, 第二个参数指定填充符, 第二个参数是可选的, 默认是空格, 如果设置宽度小于理论的宽度则返回原字符串.
    11. ljust()左对齐, 第一个参数, 蝶儿个参数指定填充字符, 第二个参数是可选的, 默认是空格如果设置宽度小于理论宽度则返回原字符串
    12. rjust()右对齐, 第一个参数指定高度, 第二个参数指定填充符, 第二个参数是可选的, 默认是空格如果设置宽度小于理论宽度, 则返回原字符串
    13. zfill()右对齐, 右边用 0 填充, 该办法只承受一个参数, 用于指定字符串的宽度, 如果指定的宽度小于等于字符串长度, 返回字符串自身 -0001234 会增加到 - 号前面
    14. split()从字符串的右边开始劈分, 默认的劈分字符串空格字符串, 返回值是一个列表, 通过参数 sep= 指定劈分字符串是劈分符号, 通过参数 maxsplist= 指定劈分字符串时最大劈分次数, 在通过最大劈分之后, 残余的字符串会独自作为一部分
    15. rsplist()从字符串最左边开始劈分, 默认的劈分字符串时空格字符串, 返回值都是一个列表, 通过 sep 指定劈分字符串的劈分符, 通过参数 maxsplit 指定劈分字符串的最大劈分次数, 在通过最大劈分之后, 残余的字符串独自作为一部分
    16. isidentifier()判断字符串是不是非法的标识符
    17. isspace()判断指定的字符串是否全副由空白字符组成(回车, 换行, 程度制表符)
    18. isalpha()判断指定的字符串是否全副有字母组成
    19. isdecimal()判断指定字符串是否全副由十进制的数字组成
    20. isnumeric()判断指定字符串是否全副由数字组成, 罗马汉字的 4 都会是 True
    21. isalnum()判断字符串是否全副由字母和数字组成和汉字
    22. join()将列表或元组的字符串合并成一个字符串, 或者更改连贯符号
    23. replace()第一个参数指定被替换的字符串, 第二个参数指定替换字符串的字符串, 该办法返回替换后失去新的字符串, 替换前的字符串不发生变化, 调用该办法时能够通过第三个参数指定最大替换数

    24. 字符串的比拟操作 >,>=,=,<,<=,==,!=

        1. 比拟规定: 首先比拟两个字符串中的第一个字符, 如果相等则持续比拟下一个字符, 一次比拟上来, 晓得两个字符串中的字符不相等时, 其比拟后果就是两个字符串的比拟后果, 两个字符串中的所有后续字符将不再被比拟
        2. 比拟原理: 两个字符串进行比拟是, 比拟的是其 ordinal value 原始值, 调用内置函数 ord 能够失去指定字符的 ordinal value. 与内置函数 ord 对应的是内置函数 chr 调用内置函数 chr 时指定 ordinal value 能够失去其对应的字符

        3. == 与 is 的区别,== 比拟的时 value,is 比拟的时 id

    25. 25. 字符串的切片操作, 字符串是不可变类型, 不具备增删改等操作, 切片操作将产生新的对象
    26. 格式化字符串 % 占位符,%s 字符串,%i 整数 %f 浮点数

    27. 字符串的编码转换, 为什么须要编码转换?, 因为传输时是 byte 字节传输的, 所以须要进行编码解码

        1. 将字符转换成二进制数据 bytes
        2. 将 bytes 类型的数据转换成字符串类型

        lst=['hello','java','python']
        print('|'.join(lst))
        t=('hello','java','python')
        print('.'.join(t))
        st='hello,java,python'
        print('/'.join(st))
        
        s='hello,Python'
        s1=s[:5]
        s2=s[6:]
        print(s1,s2)
        s3='!'
        newstr=s1+s3+s2
        print(s[::-1])# 默认从字符串的最初一个元素开始, 到字符串的第一个元素完结, 因为步长为正数, 所以是倒着的
        print(s[-6::1])# 从索引为 - 6 开始, 到字符串的 u 子最初一个元素完结, 步长为 1
        
        name='yanchenglong'
        age=20
        sorre=60.7
        print('我叫 %s, 往年 %d 岁, 我考了 %f 分数'%(name,age,sorre))
        print('我叫 {0}, 往年{1} 岁, 我考了 {2} 分数'.format(name,age,sorre))
        print(f'我叫 {name}, 往年{age} 岁, 我考了 {sorre} 分数')
        #指定宽度
        print('%10d'%99)
        print('%f'% 3.1415926)
        print('%.3f'%3.1415926)
        #同时示意宽度和精度
        print('%10.3f'%32.1415926)
        print('{0:.3f}'.format(3.1415926)) #.3f 标识是 3 位小数
        print('{0:10.3f}'.format(3.1415926))
        name='yanchenglong, 我的天'
        print(name.encode(encoding='GBK')) # 在 GBK 中这种编码格局中, 一个中文字符占两个字节
        print(name.encode(encoding='UTF-8'))# 在 UTF- 8 这种百编码格局中一个中文占三个字节
        # 解码
        byte=name.encode(encoding='UTF-8')
        print(byte.decode(encoding='UTF-8'))
        

        函数的创立和调用

        什么是函数, 函数就是执行特定任何以实现特定的性能的一段代码
        为什么须要函数

22. 代码复用
23. 暗藏实现细节
24. 进步可维护性
25. 进步可读性便于调试

函数的创立

def 函数名([输出参数]):
  函数体
  [return xxx]

def calc(a,b):
    return a+b
result=calc(10,20)
print(result)

参数传递

1. 地位实参

2. 关键字实参

   def calc(a,b): #ab 称为形式参数, 简称形参, 形参的地位是在函数的定义处
    return a+b
   result=calc(b=10,a=20)# 10,20 称为理论参数的值, 实参
   print(result)
   result=calc(10,20)# 10,20 称为理论参数的值, 实参
   print(result)
   def fun(arg1,arg2):
    print(arg1,arg2)
    arg1='100'
    arg2.append(100)
    print(arg1,arg2)
    pass
   
   n1='11'
   n2=[22,33,44]
   fun(n1,n2)
   print(n1,n2)
   # 在函数调用过程中进行参数传递, 如果是不可变对象, 在函数体的批改不会影实参的值
   # 如果是可变对象, 在函数体的批改会影响到实参的值
   
   def fun(num):
    odd=[]# 存计数
    even=[]# 存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
            pass
        pass
    return odd,even
    pass
   lst=[10,29,34,23,44,53,55]
   print(fun(lst))
   # 如果函数没有返回值,return 能够省略不写
   # 函数的返回值如果是 1 个间接返回原类型,
   # 函数的返回值如果是多个, 返回后果为元组
   
   

   函数定义默认值参数

3. 函数定义时, 给形参设置默认值, 只有与默认值不符的时候擦才会传递实参

   def fun(a,b=10):
    return a+b
    pass
   print(fun(110))

   函数的参数定义

4. 个数可变的地位参数

   1. 在定义函数的时候, 可能无奈确定传递参数的个数时, 应用可变的地位参数
   2. 应用 * 定义个数可变的地位形参
   3. 后果为一个元组

5. 个数可变的关键字参数

   1. 定义函数时, 无奈当时确定传递的关键字实参的个数时, 应用可变的要害字形参
   2. 应用 ** 定义可变的要害字形参

   3. 后果为一个字典

      def fun(*arge):
       print(arge)
       pass
      fun(111)
      
      def fun(**arge):
       print(arge)
       pass
      fun(a='1',b='2')
      def fun(*,e): # 则示意调用时传入必须应用关键字参数传递
       print(e)
       pass
      fun(e=123)
      
      def fun(a,b,c):
       print(a,b,c)
       pass
      fun(10,20,30)
      lst=[11,22,33]
      fun(*lst)# 在函数调用时, 将列表中每隔元素都转换为地位实参传入
      fun(a=100,c=30,b=1)# 关键字参数
      dic={'a':11,'b':22,'c':33}
      fun(**dic)
      def fun4(a,b,*,c,d):# 前两个参数, 采纳的是地位实参传递, 而 CD 采纳的是关键字实参传递
       print(a)
       print(b)
       print(c)
       print(d)
      
      print(fun4(10,20,c=30,d=40))
      def fun5(a,b,*,c,d,**args):
       pass
      def fun6(*args,**args2):
       pass
      def fun7(a,b=10,*args,**args2):
       pass
      

      留神传入参数的地位：

      
      def fun_a(a,name='开心呢',*args,**kwargs):
       print(a)
       print(name)
       print(args)
       print(kwargs)
      
      fun_a(100,'张三',1000,2000,x=1,y=2)

      变量的作用域

      def fun(a,b):
       c=a+b
       print(c)
       pass
      name="aidfjiajsdf"
      print(c)#c 是在函数体内是局部变量在全局中是无奈调用的;
      print(name)
      def fun2():
       global name #申明变量是全局变量, 而后就能够批改全局变量啦
       name=10
       print(name)
      fun2()
      print(name)

      如果变量内应用了全局变量, 不能是 +=, 或者 a =a+1, 如果是则须要应用 global 进行标注, 不然找不到 a + 1 的这个 a 就是局部变量的 a;

      a=100  
      def add():  
       global a  
       a+=10  
       return a # 在这里定义的 a 如果呈现在 = 号的右边也就是 a = 这样的话就是新定义生成一个 a 局部变量了, 而不是用全局变量的 a, 如果想应用全局变量须要加上 global 关键字阐明  
      print(add())

      打印后果:

      D:\pythonProject\pythonProject\venv\Scripts\python.exe D:/pythonProject/pythonProject/demo3.py 
      110
      
      Process finished with exit code 0
      

递归函数

1. 如果在一个函数的函数体内调用了改函数自身, 这个函数就成为递归函数
2. 递归的组成部分: 递归调用与递归传递终止条件
3. 递归的调用过程: 每递归调用一次函数, 都会在栈内存调配一个栈帧, 每执行完一次函数, 都会开释相应的控件

4. 递归的额优缺点, 毛病: 占用内存多, 效率低下, 长处: 思路和代码简略

   def fac(n):
    if n ==1:
        return 1
    else:
        return n*fac(n-1)
   print(fac(6))
   
   def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
   #斐波那契数列第 6 位上的数字
   print(fib(6))
   for i in range(1,7):
    print(fib(i))

   闭包函数

   def power(exp):
    def exp_off(base):
        return base ** exp
    return exp_off
   square = power(2)
   cube = power(3)
   print(square(2))
   print(cube(3))

   参数的解包

   def fun_a(x,y,z):
    print(x,y,z)
   
   fun_a(1,2,3)
   a=(1,2,3)
   # 元素解包操作, 在 a 后面加一个 * 号则会进行元组的解包, 如果加上 ** 进行字典的解包
   fun_a(*a)
   

   高阶函数

   所谓高阶函数, 须要满足上面两个条件之一

5. 承受一个或多个函数作为参数
6. 输入一个函数

# map 是要给映射, 承受两个参数, 第一个 i 而参数是一个函数, 第二个参数是序列(列表 / 元组)
# 返回值: 可迭代对象
list_a=[1,2,3,4,5]
list_b=[]
for item in list_a:
    list_b.append(item+10)
print(list_b)
# 后果:[11, 12, 13, 14, 15]
# 思考 list_b 中的数据由 list_a 中的数据依据规定生成得出

mapretul =map(lambda x:x+10,list_a)
print(list(mapretul))
# 打印后果:[11, 12, 13, 14, 15]


def add(a,b):
    return a+b
def sub(a,b):
    if a<=0:
        raise ValueError('传入的 a 太小啦不够减')
    return a-b

def calc(opr):
    if opr=='+':
        return add
    elif opr=='-':
        return sub
    else:
        raise ValueError('传入的数据谬误')

f1=calc('+')
f2=calc('-')
print('10+5=%d'% f1(10,5))
print('10-5=%d'% f2(0,5))

# 打印后果
10+5=15
Traceback (most recent call last):
  File "C:\Users\sj176\PycharmProjects\erlangshen_app_test-master\erlangshen_app_test-master\testmu.py", line 19, in <module>
    print('10-5=%d'% f2(0,5))
  File "C:\Users\sj176\PycharmProjects\erlangshen_app_test-master\erlangshen_app_test-master\testmu.py", line 5, in sub
    raise ValueError('传入的 a 太小啦不够减')
ValueError: 传入的 a 太小啦不够减

python 自带的函数

过滤函数 filter

def fun_a(a):
    return a>50
data1=[1,2,3,4,5,11,22,33,44,55,66,77,88,223]
filed=filter(fun_a,data1) # 返回一个迭代对象
#调用 list 转换为 list
print(list(filed))
打印后果
[55, 66, 77, 88, 223]

映射函数 map
map（）函数用于对容器中的元素进行映射（或变换）。例如：我
想将列表中的所有元素都乘以 2，返回新的列表。

def f1(x):
    return x*2

listData=[1,2,3,4,5,6]
mapData=map(f1,listData)
print(list(mapData))
打印后果
[2, 4, 6, 8, 10, 12]

lambda（）函数

在 Python 中应用 lambda 关键字定义匿名函数。lambda 关键字定义的
函数也被称为 lambda（）函数，定义 lambda（）

def calc(opr):
    if opr=='+':
        return lambda a,b:(a+b)
    elif opr=='-':
        return lambda a,b:(a-b)
    else:
        raise ValueError('传入的数据谬误')

f1=calc('+')
f2=calc('-')
print('10+5=%d'% f1(10,5))
print('10-5=%d'% f2(0,5))



listData=[1,2,3,4,5,6]
mapData=map(lambda x:x*2,listData)
print(list(mapData))

reduce

对每个元素进行解决,
走的逻辑是
第一次 x 是 2y 是 3 进行乘操作 =6
第二次 x 是 6y 是 4 进行乘操作 =24
以此类推

list_a = [2,3,4,4,12,3]
ret=1
for item in list_a:
    ret*=item

print(ret)
from functools import reduce
# 对每个元素进行累乘
ret=reduce(lambda x,y:x*y,list_a)
print(ret)

匿名函数

语法:

result=lambda[arg1,[arg2....argn]]:expression  
result: 用于调用 lambda 表达式  
[arg1,[arg2....argn]]可选参数, 用于指定要传递的参数列表, 多个参数间应用逗号, 宰割  
expression: 必选参数, 用于指定一个实现具体性能的表达式, 如果有参数, 那么在该表达式中利用这些参数.  

如下求出圆的面积 , 非匿名函数形式

import math  
def circlearea(r):  
    result=math.pi*r*r  
    return result  
r=20  
print('半径为 r 的园面积为',circlearea(r))  

应用匿名函数 lambda 表达式

import math  
r=20  
result=lambda r:math.pi*r*r  
print('半径为 result 的园面积为',result(r))

看着代码就简洁了许多

BUG

BUG 的常见类型

1. 大意导致的语法错误 SyntaxError

2. 大意导致的谬误宝典

   1. 漏了开端的冒号, 如果 if 语句, 循环语句,else 子句等
   2. 缩进谬误, 改缩进没有缩进, 不该缩进的瞎缩进
   3. 把英文符号写成中文符号, 比方所: 引号, 冒号, 括号
   4. 字符串拼接的时候, 把字符串和数字拼接在一起
   5. 没有定义变量, 比方所 while 循环条件的变量
   6. \=\= 比拟运算符和 = 复制运算符的混用

3. BUG 的常见类型

   1. 索引越界问题 indexError
   2. append()办法应用的把握不纯熟

4. BUG 的常见类型

   1. 思路不清导致的问题解决方案
   2. 应用 print()函数

魔法函数

1. __str__：字符串办法
2. __lt__: 小于、大于符号比拟
3. __le__: 小于等于、大于等于符号比拟
4. __eq__== 符号比拟

代码演示

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self): # 默认打印的是对象的内存地址
        return '姓名{}，年龄{}'.format(self.name,self.age)
    def __lt__(self, other):
        return self.age<other.age
    def __le__(self, other):
        return self.age<=other.age
    def __eq__(self, other):
        return self.name==other.name

stu=Student('周杰伦',19)
stu2=Student('周杰伦',19)
print(stu)
# 姓名周杰伦，年龄 19
# 进行比照 Student 的年龄看谁大
print(stu>stu2) # 如果不重写 lt 则会进行报错 打印, 用于 < or >
# 打印后果 False
print(stu>=stu2) # 如果不重写 le 则会进行报错 打印, 用于 <= or >=
print(stu==stu2) # 如果没有实现 eq 办法，则默认比拟内存地址

类型注解

为什么咱们须要注解？，在应用 pycharm 过程中，在应用办法体传入的内容的办法时，不会有提醒，其实就是应为 pycharm 无奈通过代码判断主动补全
应用办法后 pycharm 会有提醒该办法传入的什么参数

变量的类型注解

根底语法：变量: 类型
实例代码

# 根底类型注解
import json
import random


class Student:
    pass
stu:Student=Student()
var_1:int = 10
var_2:str='it'
my_list:list=[1,2,3]
my_list2:list[int]=[1,2,3]# 具体注解
my_tuple2:tuple[int,str,bool]=(1,'2',True) # 具体注解
my_dict:dict[str,int]={'key':123}
# 留神元组类型设置类型具体注解，须要将每一个元素都标记进去
# 字典类型设置类型具体注解，须要 2 各类型，第一个时 key，第二个时 value
# 除了应用变量：类型，这种语法做注解外，也能够在注解中进行类型注解。# 语法
var_8=random.randint(1,10)# type:int
var_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]
def fun():
    return 10
var_10=fun()#type:int

如下方展现，就算不写注解，也明确通晓变量类型，就不须要注解啦

stu:Student=Student()
var_1:int = 10
var_2:str='it'
my_list:list=[1,2,3]
my_list2:list[int]=[1,2,3]# 具体注解
my_tuple2:tuple[int,str,bool]=(1,'2',True) # 具体注解
my_dict:dict[str,int]={'key':123}

如果是下方，一眼看不明确的能够应用类型注解

var_8=random.randint(1,10)# type:int
var_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]
def fun():
    return 10
var_10=fun()#type:int

留神类型注解只是备注，如果写错了也不会程序报错

函数（办法）形参的注解

函数（办法）形参列表和返回值类型注解
语法：
def 函数名（形参名：类型，形参名：类型）

pass

Union 类型

问题: 如果 list 中或字典中存在多种类型那么就须要应用 Union 类型来注解
简略应用

from typing import Union
myList:list[Union[str,int]]=[1,2,'e','f']
mydict:dict[str,Union[str,int]]={"name":1,'eee':2,"d":'e',"f":'f'}

def func(data:Union[int,str])->Union[int,str]:# 传入返回字符串或者 int 类型
    pass

本文由博客一文多发平台 OpenWrite 公布！