Python简介

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

转义字符

1. 就是反斜杠+想要实现转义功能首字母. 当字符串中包含反斜杠,单引号和双银行等有特殊字符用途的字符是,必须使用反斜杠对这些字符进行转义:
   1. 反斜杠\\
   2. 单引号'
   3. 双引号"
2. 当字符串中包含换行回车,水平制表符或退格等无法直接表示的特殊字符时,也可以使用转义字符当字符串:
   1. 换行\n
   2. 回的\r(return光标移动到本行的开头,也就是前面的字符会消失)
   3. 水平制表符\t
   4. 退格\b(往前删除一个字符)

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
  • 字符串类型: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

数据类型转换

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

函数名	作用	注意事项	举例
str()	将其他数据类型转成字符串	也可以引号转换	str(123) '123'
int()	将其他数据类型转整数	1.文字类和小数类字符串,无法转化成整数,2.浮点数转化成整数:抹零取整	int('123') int(2.5)
float()	将其他数据类型转成浮点数	1.文字类无法转换成整数2.整数转换成浮点数末尾.0	float('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 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')

## 条件表达式

```python
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语句

用户结束当前循环,进入下一次循环,通常用于分支语句中的if一起使用

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

else语句

与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])

列表元素的查询操作

• 判断指定元素在列表中是否存在
  元素 in 列表名,元素 not in 列表名
• 列表元素的便利
  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)

列表修改操作

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))

列表生成式
语法格式[ii for i in range(10)]
ii表示列表元素的表达式,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设置的默认值

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])

5. 字典生成式

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的长度不一致则会取最短的进行复制压缩

6. 字典的特点
   1. key不允许重复,value可以重复
   2. 字典中的元素是无序的
   3. 字典中的key必须是不可变对象
   4. 字典也是可以根据需要动态的伸缩
   5. 字典会浪费较大的内存空间,是一种空间换时间的数据结构

元组

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

1. 不可变序列:字符串,元组
   1. 不可变序列:没有增三改的操作
2. 可变序列:列表,字典
   1. 可变序列:可以对序列执行增删改操作,对象地址不发生更改
3. 为什么要将元组设计成不可变序列?
   1. 在多任务环境下,同时操作对象是不需要加锁
   2. 因此,在程序中尽量使用不可变序列
   3. 注意事项:
      1. 元组中存储的时对象引用,如果元组中对象本身不可变对象,则不能再引用其他其他对象
      2. 如果元组中的对象时可变对象,则可变对象的引用不允许改变,但数据可以改变

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

1. 元组的创建方式
   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()

2. 元组遍历

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

集合

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

1. 集合的创建方式
   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))

2. 集合元素的判断操作
   1. in 或not in
3. 集合元素的新增操作
   1. 调用add()方法,一次添加一个元素
   2. 调用update()方法至少添加一个元
4. 集合元素的删除操作
   1. 调用remove()方法,一次删除一个指定的元素,如果指定的元素不存在抛出KyeERRPR错误
   2. discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛出异常
   3. 调用pop方法,一次删除要给任意元素
   4. clear()方法,清空集合
5. 集合之间的关系
   1. 两个集合是否相等,可以用运算符==或!=进行判断
   2. 一个结合是否是另一个集合的子集
      1. 可以调用方法issubset进行判断
      2. B是A的子集
   3. 一个集合是否是两一个集合的超集,父级
      1. 可以调用方法issuperset进项判断
      2. a是b的超集
   4. 两个集合是否没有交集
      1. 可以调用方法isdisjoint进行判断
6. 集合的数学操作
   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)

7. 集合生成式
   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))	可变	不可重复	无序	{}

字符串常用操作

1. 字符串的驻留机制
   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一次对象,效率要比+效率高
2. 字符串的常用操作
   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'))

函数的创建和调用

什么是函数,函数就是执行特定任何以完成特定的功能的一段代码
为什么需要函数

1. 代码复用
2. 隐藏实现细节
3. 提高可维护性
4. 提高可读性便于调试

函数的创建

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个直接返回原类型,
# 函数的返回值如果是多个,返回结果为元组

函数定义默认值参数

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

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

函数的参数定义

1. 个数可变的位置参数
   1. 在定义函数的时候,可能无法确定传递参数的个数时,使用可变的位置参数
   2. 使用*定义个数可变的位置形参
   3. 结果为一个元组
2. 个数可变的关键字参数
   1. 定义函数时,无法事先确定传递的关键字实参的个数时,使用可变的关键字形参
   2. 使用**定义可变的关键字形参
   3. 结果为一个字典

def fun(*arge):
    print(arge)
    pass
fun(111)

def fun(**arge):
    print(arge)
    pass
fun(a='1',b='2')

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,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)

递归函数

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))

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()函数