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# 解决方案 导入decimalfrom decimal import Decimalprint(Decimal('1.1')+Decimal('2.2'))# 3.3

数据类型转换

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

函数名作用注意事项举例
str()将其余数据类型转成字符串也能够引号转换str(123) '123'
int()将其余数据类型转整数1.文字类和小数类字符串,无奈转化成整数,2.浮点数转化成整数:抹零取整int('123') int(2.5)
float()将其余数据类型转成浮点数1.文字类无奈转换成整数2.整数转换成浮点数开端.0float('123.2') float(12)
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 keywordprint(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

运算符的优先级

***,/,//,%+,-<<<,>>>&|>,<,>=,<=,==,!=andor=""" 一个= 称为赋值运算符,==称为比拟运算符一个变量由三局部组成:id name value  应用id()函数能够看到该变量的id==比拟的就是valueis,not is比拟的时id"""a,b=10,10list1=[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 = 1i = 0while a <= 90:print('a<10', a)if not bool(a % 2):i += aa += 1print('sum', i)

for-in循环

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

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

    for-in的语法结构for 自定义的变量 in 可迭代对象:循环体
    for item in 'python':  print(item)  pass# p# y# t# h# o# nfor item in range(10):print(item)pass# 0# 1# 2# 3# 4# 5# 6# 7# 8# 9for _ in range(10):print('hello word')pass# 应用for循环,计算1到100之间的偶数和sum = 0for item in range(1,101):if item % 2 == 0:  sum += item  passpassprint(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    passa = 0while 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...elsewhile...elsefor...else

test

for item in range(3):    pwd = input('input')    if pwd == '1111':        print('yes')        break    else:        print('no')        passelse:    print('sorry 3 password error')a = 0while 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:]= lst3print(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 lstprint(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['王五']#如果获取不到则会报错KyeErrorprint(ww)print(data.get('张三'))# 如果不存在则会Noneprint(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']=1000print(data)#批改data['djij']=10print(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)) #2090536342704s+='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+s2print(s[::-1])# 默认从字符串的最初一个元素开始,到字符串的第一个元素完结,因为步长为正数,所以是倒着的print(s[-6::1])# 从索引为-6开始,到字符串的u子最初一个元素完结,步长为1name='yanchenglong'age=20sorre=60.7print('我叫%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+bresult=calc(10,20)print(result)

参数传递

  1. 地位实参

  2. 关键字实参

    def calc(a,b): #ab称为形式参数,简称形参,形参的地位是在函数的定义处 return a+bresult=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) passn1='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 passlst=[10,29,34,23,44,53,55]print(fun(lst))# 如果函数没有返回值,return能够省略不写# 函数的返回值如果是1个间接返回原类型,# 函数的返回值如果是多个,返回后果为元组

    函数定义默认值参数

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

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

    函数的参数定义

  4. 个数可变的地位参数

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

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

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

    3. 后果为一个字典

      def fun(*arge): print(arge) passfun(111)def fun(**arge): print(arge) passfun(a='1',b='2')def fun(*,e): # 则示意调用时传入必须应用关键字参数传递 print(e) passfun(e=123)def fun(a,b,c): print(a,b,c) passfun(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): passdef fun6(*args,**args2): passdef 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) passname="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 110Process 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_offsquare = 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+bdef sub(a,b):    if a<=0:        raise ValueError('传入的a太小啦不够减')    return a-bdef 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=15Traceback (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>50data1=[1,2,3,4,5,11,22,33,44,55,66,77,88,223]filed=filter(fun_a,data1) # 返回一个迭代对象#调用list转换为listprint(list(filed))打印后果[55, 66, 77, 88, 223]

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

def f1(x):    return x*2listData=[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=1for item in list_a:    ret*=itemprint(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.namestu=Student('周杰伦',19)stu2=Student('周杰伦',19)print(stu)# 姓名周杰伦，年龄19# 进行比照Student的年龄看谁大print(stu>stu2) # 如果不重写lt则会进行报错 打印,用于< or ># 打印后果Falseprint(stu>=stu2) # 如果不重写le则会进行报错 打印,用于<= or >=print(stu==stu2) # 如果没有实现eq办法，则默认比拟内存地址

类型注解

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

变量的类型注解

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

# 根底类型注解import jsonimport randomclass Student:    passstu:Student=Student()var_1:int = 10var_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:intvar_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]def fun():    return 10var_10=fun()#type:int

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

stu:Student=Student()var_1:int = 10var_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:intvar_9=json.loads('{"name":"zhangsan"}') # type:dict[str,str]def fun():    return 10var_10=fun()#type:int

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

函数（办法）形参的注解

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

pass

Union类型

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

from typing import UnionmyList: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 公布！