python笔记

1.python简介

1.python是一个跨平台计算机程序设计语言

2.python是一个解释性语言，不同于c/c++在开发过程中不需要进行编译。

3.python是一种交互式语言，可以在提示符>>>后面直接执行代码

4.python是一门面向对象的程序设计语言，一切皆对象。

2.python环境搭建

1.安装解释器

安装好后，检查环境变量，没有的记得添加：添加以下两个目录，每个人的不同

C:\Users\zero\AppData\Local\Programs\Python\Python310

C:\Users\zero\AppData\Local\Programs\Python\Python310\Scripts

2.python安装目录

DLLs:python的动态链接库

Dos：python的参考书

include:python编译器的C语言头文件源码

Lib:是python的便准库，扩展库都安装在这里

Scripts：项目用到的各种脚本

tcl:包含python的内置库的GUI工具Tkiner

Tools：python提供的一些工具

3.自带的简单ide

3.python的输出函数print

print函数使用：

1.可以输出数字

print(12345)
#12345

2.可以输出字符串

print("ni" + "hao")
#nihao

3.可以输出含运算符的表达式

print(1+2*3)
#7

print()函数可以将内容输出到：显示器、文件

fp = open("E://python/text.txt","a+")
#"a+":如果文件不存在就创建，存在就在文件后面追加
print("helloworld",file = fp)
fp.close()

print()函数的输出形式：换行、不换行

#不进行换行输出
print("hello","world","python")
#hello world python

4.转义字符

1.当字符串中包含反斜杠、单引号、双引号等特殊用途的字符时，必须使用反斜杠对这些字符进行转义

字符	表示
反斜杠	\\
单引号	\`
双引号	\“

2.当字符串中包含行、回车、水平制表、或退格符等无法直接表示的特殊字符，也可以用转义字符

字符	表示
换行(newline)	\n
回车(return)	\r
水平制表(table)	\t
退格(backspace)	\b

3.原字符，不希望字符中的转义字符起作用，就使用原字符，就是在字符串的前面加上r或R

print(r"hello\nworld")
#hello\nworld

注意最后一个字符不能是反斜杠（一个不行，两个行）

5.二进制和字符编码

1bit = 8 byte

1kb = 1024 b

1mb = 1024 kb

1gb = 1024mb

1tb = 1024 gb

计算机只能表示二进制的0和1，为了表示符号和字符，诞生了ASCII表，用某个整数表示某个字符，如大写A对应十进制的65，对应二进制的100 0001，下面是一张ASCII表。

---

后来各个国家又诞生了不同的字符编码

ASCII—>GB2312—>GBK–>GB18030—>Unicode—>UTF-8

ASCII—>其他国家字符编码—>Unicode—>UTF-8

6.python中的标识符和保留字

1.保留字

import keyword

print(keyword.kwlist)

结果：[‘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’]

2.标识符

• 变量、模块、类、函数和其他对象的起的名字就叫标识符
• 规则：
  • 字母、数字、下划线_
  • 不能以数字开头
  • 不能是保留字
  • 严格区分大小写

7.变量的定义与使用

name = "玛丽亚"
print(name)
#玛丽亚

• 变量由三部分组成
  • 标识：表示对象所储存的地址，使用内置函数id(obj)来获取。
  • 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
  • 值：表示对象所储存的具体数据，使用print(obj)可以将值进行打印输出

name = "玛丽亚"
print(id(name))
print(type(name))
print(name)
#1931233202832
#<class 'str'>
#玛丽亚

• 变量多次赋值后，变量名会指向新的空间（原先的空间会变成内存垃圾由python内存回收处理）

name = "玛丽亚"
name = "楚留冰"

8.数据类型

1. Number(数字)：

   int，float,bool,complex

   注意：python3中bool是int的子类，可以和数字相加， 可以用is来判断

2. String(字符串)

   • 字符串又称为不可变的字符序列

   • 可以用单引号，双引号，三引号来定义

   • 单引号和双引号定义的字符串必须在一行

   • 三引号定义的字符串可以分布在连续的多行

     str1 = "人生苦短，我用python"
     str2 = """人生苦短，
     我用python"""
     print(str1,type(str1))
     print(str2,type(str2))
     '''
     人生苦短，我用python <class 'str'>
     人生苦短，
     我用python <class 'str'>hanshumign
     '''

3. List(列表)

4. Tuple(元组)

5. Set(集合)

6. Dictionary(字典)

   name = "张三"
   age = 18
   #print("今年"+name+age+"岁")这行代码age会报错
   print("今年"+name+str(age)+"岁")#str()类型转换

数据类型转换函数

函数名	作用	注意事项	举例
str()	将其他数据类型转换成字符串	也可用引号转换	str(123) “123”
int()	将其他数据类型转换成整数	1. 文字类和小数类字符串无法转换成整数<br>2.浮点数转换成整数，抹零取整	int(‘123’) int(9.9)
float()	将其他数据类型转换成浮点数	1.文字类无法转换成整数、浮点数<br>2.整数转换成浮点数，末尾为.0	float(‘9.9’) float(9)

9.python中的注释

• 注释

  • 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性

  • 注释内容会被python解释器忽略

  • 通常包括三种类型的注释

    • 单行注释： 以”#“开头，直至换行结束

    • 多行注释： 并没有单独的多行注释，将一对三引号之间的代码称为多行注释

    • 中文编码声明注释： 在文件的开头加上中文声明注释，用以指定源码文件的编码格式。（中文编码注释的作用：不同编码表（如UTF-8或GBK），中文字符对应的编码都不一样，如果不进行编码声明，别人打开你的代码，很可能会因为编码格式不对出现乱码）

      #coding:utf-8

10.input函数的使用

input函数
返回值类型	接收来自用户的输入
返回值类型	输入的类型为str
值得存储	使用=对输入的值进行存储

gege = input("哥哥叫什么名字？")
print(gege,type(gege))
#哥哥叫什么名字？蔡徐坤
#蔡徐坤 <class 'str'>

input计算两数的和

a = input("请输入a")
b = input("请输入b")
print("a+b=",a+b)
#请输入a10
#请输入b20
#a+b= 1020
#---------上面为错误方法，只是将a,b两个字符进行连接---------

a = input("请输入a")
b = input("请输入b")
print("a+b=",eval(a)+eval(b))
#请输入a10
#请输入b20
#a+b= 30

---

11.python中的运算符

1. 算数运算符

算数运算符
标准算数运算符	加（+）、减（-）、乘（*）、除（/）、整除（//）
取余运算符	%
幂运算符	**

print(1+1)
print(1-1)
print(2*3)
print(7/2)
print(7//2)
print(9%7)
print(2**4)
''''''
2
0
6
3.5
3
2
16
''''''

注意：

//整除运算一正一负向下取整
11//2	5
9//-4	-3
-9//4	-3

%取余运算（一正一负要公式）
公式：余数=被除数 - 除数*（被除数//除数）
9%-4	-3
9-（-4）*（9//（-4））	-3

2. 赋值运算符

=
执行顺序	从右往左
支持链式赋值	a=b=c=20
支持参数赋值	+=，-=，*=，/=,//=,%=
支持系列解包赋值	a,b,c=20,30,40

#系列解包赋值可用在交换变量的值
a,b = 20,30
a,b = b,a
print(a,b)
#结果：30 20

3. 比较运算符

比较运算符(返回布尔值类型)
>, < , >= , <= ,!=
==	对象value的比较
is , is not	对象的id的比较

4. 布尔运算符

运算符	备注
and (c中&&)	两个都为真才为真
or (c中||)	一个为真则为真
not (c中!)

运算符
in	判断含有某元素
not in	判断不含某元素

s = 'hello'
print('h' in s)
print('b' not in s)
'''
结果：
True
True
'''

5. 位运算符

运算符	备注(byte举例)
位与 &	0b0000 1001 & 0b0000 0111 = 0b0000 0001
位或 |	0b0000 1001 | 0b0000 0111 = 0b0000 1111
左移运算符 <<	高位溢出舍弃，低位补零 0b0000 1001 << 2 = 0b0010 0100
右移运算符 >>	低位溢出舍弃，高位补零 0b0000 1001 >>2 = 0b0000 0010
按位异或^	结果不同同则真，同则假 0b0000 1001 ^ 0b0000 0111 = 0b0000 1110
按位取反~	0b0000 1111 （15） 求原码：0000 1111 求反码：0000 1111 求补码：0000 1111 取反：1111 0000 求反码(负数为补码减一):1110 1111 求原码(最高位不变，其余反)：1001 0000（-16） 规律：x = -(x+1)

6. 运算符的优先级

（）—>算术运算符–>位运算符—>比较运算符—>布尔运算符—>赋值运算符

最上的优先
**
*，/，//，%
+，-
<<,>>
&
|
<,>,>=,<=,==,!=
and
or

---

12.结构化程序

1. 顺序结构

   • 程序从上到下顺序地执行代码，中间没有任何的判断和跳转，直至程序结束

2. 选择结构

   • 根据条件的布尔值选择性地执行部分代码

score = int(input('请输入分数：'))
if(score<60):
    print('不及格')
elif(score<80):
	print('良好')
elif(score<90):
    print('优秀')
else:
	print('完美')

a = int(input('请输入第一整数'))
b = int(input('请输入第二个整数'))
print( str(a)+'大于'+str(b) if a>b else str(a)+'小于'+str(b))

• pass语句：语句什么都不做，只是一个占位符，用在语法上需要语句的地方，在搭建好结构没想好代码的时候用。

3. 循环结构

• range()函数的使用

  • 用于生成一个整数序列

  • 创建方式：

    1.range(stop):创建一个0-stop之间的整数序列步长为1

    2.range(start,stop):创建一个start-stop之间的整数序列，步长为1

    3.range(start,stop,step):创建一个start-stop之间的整数序列，步长为step

• 返回值是一个迭代器对象

• range类型的优点：不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要储存start,stop和step,只有用到range对象时，才会计算序列中的相关元素

• in 和 not in 判断整数序列是否存在（不存在）指定的整数

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

• while循环

a = 0
while a<9:
    print(a)
    a += 1

• for-in循环
  • in表达从（字符串、序列等）中依次取值，又称遍历
  • for-in循环便利的对象必须是可迭代的对象

for i in range(10):
    print(i)

for i in 'hello':
    print(i)
    
for _ in range(10):
    print('hello world')

• break语句：用于结束循环

• continue语句：用于结束当前循环，进入下一次循环

• else与while,for搭配使用：循环正常结束执行else中代码

for i in range(3):
    pwd = input("请输入密码")
    if pwd == '8888':
        print('正确')
        break
    else:
        print('请重新输入')
else:
    print(三次均错误')

---

13.列表

• 变量可以存储一个元素，而列表可以是一个大容器可以存储N个元素

• 列表相当于其他语言的数组

• 列表对象存储，列表元素的id

• 创建方式：

  • 使用中括号[] :lst = [‘hello’ , ‘world’ , 98]
  • 调用内置函数list() :lst = list([‘hello’ , ‘world’ , 98])

• 特点：

  列表的特点
  列表元素按顺序有序排列
  索引映射唯一一个数据
  列表可以存储重复数据
  任意数据类型混存
  根据需要动态分配和回收内存

• 列表的查询操作：

  • 获取列表中的指定元素的索引

    index()
    如果列表中存在N个相同元素，只返回相同元素的第一个元素的索引
    如果查询的元素在列表中不存在，则会抛出ValueError
    还可以在指定的start和stop之间进行查找

    lst = ['hello','python',98]
    print(lst.index('hell0'))

    -

  • 获取列表中的单个元素

    获取单个元素
    正向索引从0到N-1，如：lst[0]
    逆向索引从-N到-1 ， 如：lst[-N]
    指定索引不存在，抛出IndexError

  • 获取列表的多个元素

    • 语法格式：

    列表名[start : stop : step]

    切片操作：
    切片结果：原列表片段的拷贝
    切片范围：（start,stop）
    step默认为1，简写[start:stop]
    step为正数时从start往后切： [:stop:step]->切片第一个元素默认是列表的第一个元素 [start::step]->切片最后一个元素默认是列表的最后一个元素
    step为负数时从start往后切： [:stop:step]->切片的的一个元素默认是列表的最后一个元素 [start::step]->切片的最后一个元素默认是列表的第一个元素

  lst = [10,20,30,40,50,60,70]
  print(lst[1:6])
  print(lst[1:6:2])
  print(lst[:6:2])#默认start为0
  print(lst[1::2])#默认stop为最后一个
  print(lst[:-8:-2])#默认start为-1或6，从start开始倒着切
  print(lst[-1::-2])#默认stop为第一个元素，从start开始倒着切
  '''
  [20, 30, 40, 50, 60]
  [20, 40, 60]
  [10, 30, 50]
  [20, 40, 60]
  [70, 50, 30, 10]
  [70, 50, 30, 10]
  '''

  • 判断指定元素在列表中是否存在：

    元素 in或not in 列表

  • 列表元素的遍历：

    for 迭代变量 in 列表名

• 列表元素的增加：

方法	操作描述
append()	在列表末尾添加一个元素
extend()	在列表末尾添加至少添加一个元素
insert()	在列表任意位置添加一个元素
切片	在列表任意位置添加至少一个元素

lst = [10,30]
lst1 = ['hello','world']
lst2 = [50]
lst.append(40)
lst.insert(1,20)
lst.extend(lst1)
print(lst)
lst[1:] = lst2 #从1开始切掉后面，添加lst2 ，即切出一个位置添加lst2到该位置
print(lst)
#[10, 20, 30, 40, 'hello', 'world']
#[10, 50]

• 删除操作

  方法/其他	操作描述
  remove()	一次删除一个元素 重复元素只能删除第一个 元素不存在抛出ValueError
  pop()	删除一个指定索引位置上的元素 指定索引不存在抛出IndexError 不指定索引，删除列表中最后一个元素
  切片	一次至少删除一个元素
  clear()	清空列表
  del	删除列表:del list(一个对象)

  lst = [10,20,30,40]
  lst.remove(10)#移除第一个10
  lst.pop(2)#移除最后一个40
  lst = lst[1:]#从最后一个往后切片
  print(lst)
  #[30]

• 修改操作

  操作
  为指定索引的元素赋一个新值	lst[1] = 1
  为指定的切片赋予一个新值	lst[1:3] = [2]

  lst = [10,20,30,40]
  lst[0] = 1
  lst[1:3] = [2]
  print(lst)
  #[1, 2, 40] 

• 排序操作

  操作
  调用sort()方法，列表从小到大排序，可指定reverse = True进行降序排列,原列表上排序，并未改变列表	lst.sort(reverse(True))
  调用内置函数sorted(),可以指定reverse = True 进行降序排列，原列表不发生改变，产生一个新的列表	lst1 = sorted(lst)

• 列表生成式

  语法格式：[i*i for i in range(10)]

  i*i:列表元素的表达式

  i:自定义变量

  注意：表示列表元素的表达式中通常包含自定义变量

---

14.字典

• 字典：

  • python内置的数据结构之一，与列表一样是一个可变序列
  • 以键值对的方式存储数据，字典是一个无序的序列
  • hash函数计算存储位置，hash(key)

• 字典实现原理：

  与查字典类似，查字典时先根据部首或拼音查找对应页码，而python中字典时根据key查找value所在的位置

• 字典创建

  • 最常用方式：使用花括号

    scores = {‘张三’ :100,’李四’:98 ,’王五’:65}

  • 使用内置函数dict()

    dict(name = ‘jack’,age = 20)

scores = {'张三' :100,'李四':98 ,'王五':65}
dict1 = dict(name = 'rose',age = 20)
print(scores)
print(dict1)
#{'张三': 100, '李四': 98, '王五': 65}
#{'name': 'rose', 'age': 20}

• 字典常用操作

  • 元素获取：

    方法	举例
    []	scores[‘张三’]	[]如果字典不存在指定key，抛出keyError
    get()	scores.get(‘张三’)	get()方法取值，如果字典中不存在指定值，并不会抛出KeyError而是返回None,可以通过参数设置默认的value，以便指定的key不存在时返回

    scores = {'张三' :100,'李四':98 ,'王五':65}
    dict1 = dict(name = 'rose',age = 20)
    print(scores['张三'])
    print(dict1.get('name'))
    print(scores.get('赵四',1212))#找不到指定值，返回默认值1212
    #100
    #rose
    #1212

  • key的判断

    key的判断
    in	指定的key在字典中存在返回True	‘张三’ in scores
    not in	指定的key在字典中不存在返回True	‘Marry’ not in scores

  • 字典元素增删改

    操作
    删除	del scores['张三']
    清空	scores.clear()#字空字典元素
    新增	scores['jack'] = 90
    修改	scores['张三'] = 52

  • 获取字典视图

    操作
    keys()	获取字典中所有key
    values()	获取字典中所有value
    items()	获取字典中所有key,value对

    scores = {'张三' :100,'李四':98 ,'王五':65}
    keys = scores.keys()
    values = scores.values()
    items = scores.items()
    print(keys,type(keys))
    print(values,type(values))
    print(items,type(items))
    print(list(keys))#将所有keys组成的视图转换成列表
    '''
    dict_keys(['张三', '李四', '王五']) <class 'dict_keys'>
    dict_values([100, 98, 65]) <class 'dict_values'>
    dict_items([('张三', 100), ('李四', 98), ('王五', 65)]) <class 'dict_items'>['张三', '李四', '王五']
    '''

  • 元素的遍历

    scores = {'张三' :100,'李四':98 ,'王五':65}
    for item in scores:
        print(item,scores[item],scores.get(item))
    '''
    张三 100 100
    李四 98 98
    王五 65 65
    '''

  • 字典的特点

    • 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
    • 字典中的元素是无序的
    • 字典中的key必须是不可变的对象
    • 字典也可以根

  • 字典生成式

    • 内置函数zip()

      用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表

    items = ['fruits','books','others']
    prices = [96,78,85,100]#多出一个100，没有键对应，不会被打包,以元素少的为基准
    d = {item.upper():price for item,price in zip(items,prices)}
    print(d)
    #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

---

15.元组

• 元组

  python的内置数据结构之一，是一个不可变序列

• 不可变序列与可变序列

  • 不可变序列：字符串，元组

    没有增删改的操作

  • 可变序列：列表，字典

    可以对序列执行增删改操作，对象地址不发生改变

• 元组的创建方式

  • 直接小括号

    t = ('python','hello',90)

  • 使用内置函数

    t = tuple(('python','hello',90))

  • 只包含一个元组的元素需要使用逗号和小括号

    t = (10 ,)

为什么要将元组设计成不可变序列？

• 多任务环境下，同时操作对象时不需要加锁

• 因此，在程序中尽量使用不可变序列

• 注意：

  • 元组储存的是对象的引用
  • 如果元组中对象本身是不可变对象，则不能在引用其他对象
  • 如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以该改变

• 元组的遍历

  元组是可迭代对象，所以可以使用for-in进行遍历

  t = tuple(('hello','python',100))
  for item in t:
      print(item)
  '''
  hello
  python
  100
  '''

---

16.集合

• 集合

  • python语言提供的内置数据结构
  • 与列表、字典一样都属于可变类型的序列
  • 集合是没有value的字典
  • 集合中元素是无序的，且不允许重复元素

• 集合的创建：

  s = {1,2,3,4,5,5,6,7,7}#集合元素不允许重复，会自动去重
  #内置函数法
  s1 = set((1,2,3,4,5,5,6,7,7))
  s2 = set([1,2,3,4,5,56])
  s3 = set(range(10))
  s4 = set('python')
  print(s4,type(s4))
  #{'h', 'p', 'y', 't', 'o', 'n'} <class 'set'>

  空集合:

  s1 = {}#这个为空字典，不是空集合
  s2 = set()
  print(type(s1),type(s2))
  #<class 'dict'> <class 'set'>

• 集合的操作

  • 集合元素的判断:

    in 或not in

  • 集合元素的新增：

    • 调用add()方法，一次添加一个元素
    • 调用update()方法，一次至少添加一个元素

    s = {1,2,3,4}
    s.add(5)
    s.update([6,7,8])
    print(s)
    #{1, 2, 3, 4, 5, 6, 7, 8}

  • 集合元素的删除操作：

    • 调用remove()方法，一次删除一个指定元素，如果指定元素不存在抛出KeyError
    • 调用discard()方法，一次删除一个指定元素，如果指定元素不存在不抛出异常
    • 调用pop()方法，一次只删除一个任意元素
    • 调用clear()方法，清空集合

    s = {1,2,3,4}
    s.remove(2)
    s.discard(20)#删除不存在元素不抛异常
    s.pop()
    print(s)
    s.clear()#集合清除
    print(s)
    #{3, 4}
    #set()

• 集合关系

  • 两个集合是否相等

    可以使用 == 和 !=进行判断

  • 一个集合是否是另一个集合的子集

    • 可以调用issubset()方法判断

  • 一个集合是否是另一个集合的超集

    • 可以调用issuperset()方法进行判断

  • 两个集合是否没有交集

    • 调用isdisjoint()方法判断

s = {1,2,3,4}
s1 = {1,2,3,4}
s2 = {1,2,3,4,5}
print(s == s1)
print(s.issubset(s1))#判断是否为子集
print(s2.issuperset(s))#判断是否为超集
print(s.isdisjoint(s2))#判断是否没有交集
'''
True
True
True
False
'''

• 集合的数学操作

名称	函数方法
交集(AB)	intersection() s1 & s2
并集(A+B)	union() s1 | s2
差集(A-B)	difference() s1 - s2
对称差集(A+B-AB)	symmertric_difference() s1 ^ s2

• 集合生成式

  {i*i for i in range(1,10)}

---

列表、字典、元组、集合总结

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

---

17.字符串

• 字符串

  在python中字符串是基本数据类型，是一个不可变的字符序列

• 字符串的驻留机制

  • 什么叫做字符串的驻留机制？

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

  • 驻留机制的几种情况

    • 字符串的长度为0或1时
    • 符合标识符的字符串
    • 字符串只在编译时进行驻留，而非运行时
    • [-5,256]之间的整数

  • sys中的intern方法强制2个字符串指向同一个对象

• 驻留机制的优缺点

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

• 字符串的常用操作

  • 字符串的查询操作

  方法名称	作用
  index()	查找子串substr第一次出现的位置，如果查找的子串不存在，则抛出ValueError
  rindex()	查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError
  find()	查找子串substr第一次出现的位置，如果查找的子串不存在，则返回-1
  rfind()	查找子串substr最后一次出现的位置，如果查找的字串不存在时，返回-1

  • 字符串大小写转换操作的方法

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

  • 字符串内容的对齐操作

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

  • 字符串的拆分操作

  方法名称	作用
  split()	1.从字符串的左边拆分，默认拆分字符为空格，返回值是一个列表 2.以通过参数sep指定分隔符 3.以通过参数maxsplit指定拆分字符时的最大拆分次数，在经过最大拆分次数后剩余部分会单独做一部分
  rsplit()	1.从子串的右边开始拆分，默认拆分字符为空格，返回值是一个列表 2.以通过参数sep指定分隔符 3.通过参数maxsplit指定最大拆分次数，达最大次数后，剩余字符做一部分

  • 字符串的判断

  方法名称	作用
  isidentifier()	判断指定字符串是不是合法的标识符
  isspace()	判断指定的字符串是否全部由空白字符组成（回车，换行，制表符）
  isalpha()	判断指定的字符串是否全部由字母组成
  isdecimal()	判断指定的字符串是否全部由十进制的数字组成
  isnumeric()	判断指定的字符串是否全部由数字组成
  isalnum()	判断指定的字符串是否全部由字母和数字组成

  • 字符串的替换和合并

  方法名称	作用
  replace()	第1个参数指定被替换的子串 第2个参数指定替换字串的字符串，该方法返回替换后得到的字符串，原字符串并未发生改变，可以通过第3个参数指定最大替换次数
  join()	将列表或元组中的字符串合并成一个字符串

  • 字符串的比较

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

  • 字符串的切片操作

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

  • 格式化字符串

    两种方式：

    1.%做占位符：'我的名字叫：%s,今年%d岁了'%(name,age)

    2.{}做占位符:'我的名字叫{0}，今年{1}岁了，我真的叫：{0}'.format(name,age)

  • 字符串的编码与解码

    • 编码：将字符串转换成二进制数据
    • 解码：将bytes数据转换成字符串类型

  s = '天涯共此时'
  #编码
  print(s.encode(encoding="GBK"))
  #解码
  byte1 = s.encode(encoding="GBK")
  print(byte1)
  print(byte1.decode(encoding='GBK'))
  '''
  b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
  b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
  天涯共此时
  '''

---

18.函数

• 函数创建

  def 函数名({[输入参数]})：

  ​ 函数体

  ​ [return xxx]

def sum(a,b):
    return a+b;
print(sum(1,10))
#11

• 参数传递

  • 位置实参

    根据形参的对应位置进行实参传递

  • 关键字实参

    根据形参的名称进行实参传递

  def calc(a,b):
      return a+b;
  #位置实参
  calc(1,2)
  #关键字实参
  calc(b=2,a=1)

  • 值传递，地址传递

    值传递：如果为不可变对象即为值传递

    地址传递：如果为可变对象即为地址传递

  def test(arg1,arg2):
      print(arg1,arg2)
      arg1 = 100
      arg2.append(10)
      print(arg1,arg2)
  n1 = 10
  n2 = [10,20,30]
  test(n1,n2)
  print(n1,n2)
  '''
  10 [10, 20, 30]
  100 [10, 20, 30, 10]
  10 [10, 20, 30, 10] 
  '''

• 函数的返回值

  • 函数返回值为多个值时，返回结果为元组

• 函数的默认值参数

  def fun(a,b=10):
  	print(a,b)
  fun(1,2)
  fun(1)
  '''
  1 2
  1 10
  '''    

• 不定长参数

  • 位置参数数量可变
    • 定义函数时，无法事先确定传递的位置参数的个数时，使用可变的位置参数
    • 使用*定义个数可变的位置参数
    • 以元组形式传入
  • 关键字形参数量可变
    • 定义函数时，无法事先确定传递的关键字实参个数时，使用可变的关键字形参
    • 使用**定义个数可变的关键字形参
    • 以字典形式传入

  def fun1(*args):
      print(args[0])
      print(args)
  def fun2(**args):
      print(args)
  fun1(10)
  fun1(1,2,3)
  fun2(a = 1,b = 2, c = 3)
  '''
  10
  (10,)
  1
  (1, 2, 3)
  {'a': 1, 'b': 2, 'c': 3}
  '''