Python

Python

Python是一种面向对象的高级编程语言

注释

#  注释  ctrl + / 注释生成或取消

'''
 中间为注释
'''

数据类型

字符串类型 使用单引号或者双引号

整型(int)、浮点型(float)、复数(complex)、字符串(str)

列表类型 (list)

names = ['风清扬','林青霞','梅超风']

字典类型(dict)

person = {'name':'小明','age':18,'addr':'四川','身高':'180cm'}

元组类型(tuple)

nums = (1,8,9,2,3,0)

集合类型(set)

x = {9,'hello','hi','good',True}

布尔类型(bool)

首字母大写：False True

查看数据类型

#使用type内置类可以查看一个变量对应的数据类型
print(type(a))

在python里，变量是没有数据类型的，我们所说的变量的数据类型，其实是变量对应值的数据类型

标识符和关键字

标识符 ：变量、模块名，函数名，类名…….

标识符的命名规则与规范：

• 规则：

  1. 由数字、字母、下划线组成，不能以数字开头
  2. 严格局分字母大小写
  3. 不能使用关键字（在Python语言里，有特色含义的单词）

• 规范：

  1. 遵守一定的命名规范

     1. 小驼峰命名法：第一个单词的首字母小写，以后每个单词的首字母都大写

     2. 大驼峰命名法：每个单词的首字母都大写

     3. 使用下划线连接：如：user_name_and_password

        #在python里的变量，函数和模块名使用下划线连接；类名使用大驼峰命名法

输出

Python里使用 print内置函数 ，来输出内容

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

• sep 参数用来表示输出时，每个值之间使用哪种字符作为分隔。默认使用空格作为分隔符

• end 当执行完一个print语句以后，接下来要输出的字符。默认 \n 表示换行

输入

Python里使用 input内置函数 接受用户的输入

不管用户输入什么，变量保存的结果都是字符串

整数的表示方式

二进制、八进制、十六进制、十进制 在Python都能表示

a = 98 #默认数字都是十进制数字

b = 0b101101101 # 以0b开头的数字是二进制

c = 0o34 # 以0o开头的数字是八进制

d = 0x23 # 以0x开头的数字是十六进制

##    当使用print语句打印一个数字时，默认是使用十进制打印输出

使用代码进行进制转换

a = 12
#十进制转换为二进制
print(bin(a))

#十进制转换为八进制
print(oct(a))

#十进制转换为十六进制
print(hex(a))

数据类型的转换

使用 int 内置类可以将其他类型数据转换为整数

age = int(age)

其他数据类型必须是合法数字

x = '1a2c'
y = int(x,16) #把字符串 1a2c 当作十六进制转换成整数

• 其他类型同理

在Python中，只有空字符串‘ ’ ，“ ”，数字0，空列表[ ]，空字典{}，空元组（），空集合set（），空数据None会被转换成False，其他的都被转换成True

在计算机里，True和False其实是数字 1 和 0 来保存的

print(True + 1) #2
print(False + 1) #1

运算符

• 在Python3中两个整数相除的结果是一个浮点数

注：

print(3 ** 3) #27
#  **为幂运算

print(10 // 3) #3       整除，只取整数部分
print(-5 // 2) #-2.5    取整，都是向下取整

• 字符串里只支持加法和乘法运算符

  1、加法运算符： 将多个字符串拼接为一个字符串

  2、乘法运算符： 可以用于数字和字符串之间，用来将一个字符串重复多次

  print('hello' * 2)   #hellohello
  

• 赋值运算符特殊场景

  #拆包
  m,n = 3,5
  x = 'hello','world','person'
  
  o,*p,q = 1,2,3,4,5,6
  print(o,p,q) #    1 [2, 3, 4, 5] 6
  ##    有*的变量名即为可变长度
  

• 比较运算符

  print('abc' > 'b') # Flase 因为（a）97<（b）98
  
  # 字符串之间使用比较运算符，会根据各个字符的编码值逐一比较
  # 如上面 a,b,c 都会与b比较
  

  数字和字符串之间，做 == 运算结果为False，做 ！= 为True

• 逻辑运算符

  1、逻辑与：and

  2、逻辑或：or

  3、逻辑非：not

  逻辑运算符的短路：and有一个不行就都不行，or有一个行就都行

  逻辑运算的结果，不一定是布尔值 如下：

  逻辑与运算做取值时，取第一个为False的值；如果所有的运算数都是True，取最后一个值

  print(3 and 5 and 0 and 'hello') # 0
  print('good' and 'yes' and 'ok' and 100) # 100
  

  逻辑或运算做取值时，取第一个为True的值；如果所有的运算数都是False，取最后一个值

  print(0 or [] or 'list' or 5 or 'ok') # list
  print(0 or [] or {} or ()) # ()
  

• 位运算符

  1. 按位与 & ：同为1，否则为0

  2. 按位或 **| ** ：同为1则为1，否则为0

  3. 按位异或 ^ ：相同为0，不同为1

  4. 按位左移 << ：即在右边补0 或者（ a << n ==> a * 2的n次方）

     x = 5         # 101
     print(x << 3) # 101000
                   # 也可以  5*2的三次方
     

  5. 按位右移 >> ：即在左边补0 或者（ a << n ==> a / 2的n次方）

  6. 按位取反 ~

     按位运算将化成二进制运算，然后化成十进制显示

运算符的优先级

• 逻辑运算符

  not > and >or

条件判断语句

Python里不支持 switch…case 语句

if

• if语句格式

  age = int(input('请输入你的年龄'))
  if age < 18:
      print('未满十八岁，禁止入内')
  
  

• if…else语句格式

  age = int(input('请输入你的年龄'))
  if age < 18:
      print('未满十八岁，禁止入内')
  else:
      print('已满十八岁，可以入内')
  
  

• if…elif…elif语句格式

  socre = int(input('请输入成绩'))
  if 60 > socre >= 0:
      print("菜")
  elif 80 > socre >= 60:
      print('一般般')
  elif 100 >= socre >= 80:
      print('还可以')
  else:
      print('输入错误')
  

Pytho语言里，使用强制缩进来表示语句之间的结构

pass 关键词在python里没有意义，只是单纯的用来占位，保证语句的完整性

注意点

1. 区间判断：

   Python里可以使用连续的区间判断，如： 100 > X > 50

   而在有些语言中，需要逻辑运算符连接

三元表达式

num1 = int(input('please input:'))
num2 = int(input('please input again:'))
x = num1 if num1 > num2 else num2
print('较大数',x)

循环语句

Python里不支持 do…while 循环

一、while

Python里没有自增自减运算符（即：++、- -）

while x < 10:
    print('hello')
    x += 1

• 例子：九九乘法表

  #九九乘法表
  i = 0
  while i < 9:
      i += 1
      j = 0
      while j < i:
          j += 1
          print(j,'*',i,'=',j*i,sep='',end='\t')   #sep用来收缩，\t用来均匀空格
      print()
  

二、for…in

和C语言的for不一样

for语句格式：for ele in iterable

注意：in 的后面必须放可迭代对象（如: 字符串、列表、字典、元组、集合、range）

1、range

range 内置类用来生成指定区间的整数序列

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

  #	1
  #	2
  #	3
  #	4
  #	5
  #	6
  #	7
  #	8
  # 9 

三、for…else

for…else语句： 当循环中得break没有被执行时，就会执行else

如：

for i in rang(101,201):
    
	for j in range(2,10):
    	if   :
        	break
else:
   xxxxx

break和continue

• break：用来结束整个循环

• continue: 用来结束本轮循环，开启下一轮循环

字符串

pythonASCII码与字符相互转换

---

print(ord('a')) #97	
print(chr(97)) #a

字符串的下标和切片

字符串是不可变数据类型

下标

word = 'hello'
print(word[1])       #e

注意：
word[1] = x #为错误行为，不能更改字符串内容

切片

切片就是从字符串里复制一段指定内容，生产一个新的字符串

m[startstep ​]

m = 'asdfghjkl'
print(m[1:6])    #sdfgh      只包含start，不包含end
print(m[1:6:2]) #sfh         每隔step-1个取一次
print(m[6:1:-1]) #jhgfd      step取负数，表示从右向左获取
print(m[-8:-1])  #sdfghjk

字符串常见的操作

• 获取长度：len

• 查找内容：find、index、rfind、rindex

• 判断：startswith、endswith、isalpha、isalnum、isspace、isdigit

• 机算出现次数：count

• 替换内容：replace

• 切割字符串：split、rsplit、splitlines、partition、rpartition

• 修改大小写:capitalize、title、upper、lower

• 空格处理：ljust、rjust、center、lstrip、rstrip、strip

• 字符串拼接：join

x = 'qwertylp'
#获取字符串长度
print(len(x))

#查找内容相关的方法 find/index/rfind/rindex 可以获取指定字符的下标
print.(x.find('l')) #6 其他用法相同

#replace:用来替换字符串
word = 'hello'
m = word.replace('l','x')
print(word)      #hello    因为在python中字符串是不可变数据类型
print(m)		 #hexxo

内容分割相关的操作

• split方法，可以将一个字符串切割成一个列表(rsplit用法和它大致相同)

  x = 'wang-ren-min-tian-di-ke-wei'
  y = x.split('-')
  print(y) #['wang', 'ren', 'min', 'tian', 'di', 'ke', 'wei']
  
  print(x.split('-',2)) #['wang', 'ren', 'min-tian-di-ke-wei']
  

• rsplit:

  x = 'wang-ren-min-tian-di-ke-wei'
  y = x.split('-')
  print(y) #['wang', 'ren', 'min', 'tian', 'di', 'ke', 'wei']
  
  print(x.rsplit('-',2)) #['wang-ren-min-tian-di', 'ke', 'wei']
  

• partition:将指定一个字符串作为分隔符，分为三部分(rpartition用法和它大致相同)

  print('asdfdghj'.partition('d')) #('as', 'd', 'fdghj')
  
  print('asdfdghj'.rpartition('d')) #('asdf', 'd', 'ghj')
  
  

修改大小写

• capitalize:让第一个单词的首字母大写

  print('hello'.capitalize)  #Hello
  

• upper:全大写

  print('hello'.upper()) #HELLO
  

• lower:全小写

  print('WoRLd'.lower()) #world
  

• title: 每个单词的首字母大写

  print('good morning'.title()) #Good Morning
  

空格处理

• ljust:向右补空格

   # ljust(width,fillchar)  width长度，fillchar填充字符，默认是空格
      print('Monday'.ljust(10)) #Monday    在右边补了五个空格
  

• rjust：与ljust类似

• center：返回指定长度的字符串，并在两端使用空白字符补全（居中对齐）

  print('hello'.center(10))#  hello   两端加空格，让内容居中
  

• lstrip:删除 x 左边的空白字符

  x = '    he    llo   '
  print(x.lstrip()) #he    llo   只去掉左边，其余空字符保留
  

• rstrip:删除 x 右边的空白字符

  x = '    he    llo   '
  print(x.lstrip()) #    he    llo只去掉右边边，其余空字符保留
  

将列表转换成字符串

fruits = ['apple','pear','peach','banana']
print('-'.join(fruits)) #apple-pear-peach-banana

字符集

• ord:获取字符对应的编码

  print(ord(a)) #字符对应的编码是 97
  

• chr:根据编码获取对应的字符

  print(chr(65)) #A
  

成员运算符

in和not in 运算符：用来判断一个内容在可迭代对象里是否存在

word = 'hello'
x = input('输入:')
if x in word:
    print('存在')
else:
    print('不存在')

if x not in word:
    print('不存在')
else:
    print('存在')

格式化打印字符串

在字符串中可以使用 % 占位符

• %s表示的是字符串的占位符

• %d表示的是整数的占位符

  %nd打印时，显示n位，如果不够，在前面使用空格补齐

• %f表示的是浮点数的占位符（默认6位小数）

  %.nf打印时，表示显示n位小数

• %x将数字使用十六进制输出

name = 'zhangshan'
age = 18
height = 183.0
print('大家好,我的名字是%s,今年%d岁,身高%.1f' % (name,age,height))
#大家好,我的名字是zhangshan,今年18岁,身高183.0

字符串的format方法的使用

• {}:

  x = '大家好，我是{}，我今年{}岁'.format('张三',18)
  print(x)
  

• {数字}：

  y = '大家好，我是{1},我今年{0}岁了'.format(20,'张三')
  print(y)
  

• {变量名}：

  z = '大家好，我是{name},我今年{age}岁了,我来自{adder}'.format(age = 18,name = '张三',adder = '襄阳')
  print(z)
  
  

• 混合使用 {数字} {变量}：

  a = '大家好，我是{name},我今年{1}岁了，我来自{0}'.format('泰国'，23，name='tony')
  print(a)    #注意：变量要放在后面
  

• 用列表:

  d = ['zhangsan',18,'上海',180]
  b = '大家好，我是{}，我今年{}岁了，我来自{}，身高{}cm'.format(d[0],d[1],d[2],d[3])
  #或者
  b = '大家好，我是{}，我今年{}岁了，我来自{}，身高{}cm'.format(*d)
  

• 用字典:

  info = {'name':'chris','age':'18','addr':'北京','height':190}
  c = '大家好，我是{name}，我来自{addr}，身高{height}cm，我今年{age}岁'.format(**info)
  print(c)
  

列表（list）

列表是用来保存多个数据的

列表的基本使用

• 基本表达：

  name = ['张三','李四','王五']
  print(name) #['张三', '李四', '王五']
  
  

• 用下标修改表里元素：

  name = ['张三','李四','王五','马超','关羽']
  name[3] = '花木兰'
  print(name)
  #['张三', '李四', '王五', '花木兰', '关羽']
  

• 用下标实现切片：

  name = ['张三','李四','王五','马超','关羽']
  print(name[1:4])
  #['李四', '王五', '马超']
  

• 用下标获取元素：

  name = ['张三','李四','王五','马超','关羽']
  print(name[2])
  #王五
  

列表的操作

操作列表，一般都包含增删改查数据

• 添加元素（append insert extend）：

  1. append(在列表的最后面追加一个数据):

     heros = ['林青霞','王祖贤','张曼玉']
     heros.append('张国荣')
     print(heros)
     #['林青霞', '王祖贤', '张曼玉', '张国荣']
     

  2. insert(index,object):

     heros = ['林青霞','王祖贤','张曼玉']
     heros.insert(2,'吴彦祖')
     #['林青霞', '王祖贤', '吴彦祖', '张曼玉']
     

  3. extend(iterable) 需要一个可迭代对象:

     heros = ['林青霞','王祖贤','张曼玉']
     x = ['刘德华','张学友']
     heros.extend(x)
     print(heros)
     #['林青霞', '王祖贤', '张曼玉', '刘德华', '张学友']
     

  ​

• 删除数据 （pop remove clear）：

  1. pop:

     ​ 默认删除列表最后一个元素，并且返回这个元素

     heros = ['林青霞','王祖贤','张曼玉']
     print(heros.pop())
     #张曼玉
     

     ​ 还可以传入index参数，用来删除指定位置上的数据

     heros = ['林青霞','王祖贤','张曼玉']
     print(heros.pop(0))
     #林青霞
     

  2. remove（指定删除对象）：

     heros = ['林青霞','王祖贤','张曼玉']
     heros.remove('王祖贤')
     print(heros)
     #['林青霞', '张曼玉']
     

  3. clear (用来清空一个列表) ：

     heros = ['林青霞','王祖贤','张曼玉']
     heros.clear()
     print(heros)
     #[]
     

• 查询方法

  1. index(查询位置)：

     Bf = ['林青霞','王祖贤','张曼玉']
     print(Bf.index('王祖贤'))
     #1
     

  2. count(查询数量个数):

     Bf = ['张曼玉','林青霞','王祖贤','张曼玉']
     print(Bf.count('张曼玉'))
     #2
     

  3. in:

     Bf = ['张曼玉','林青霞','王祖贤','张曼玉']
     print('王祖贤' in Bf)
     True
     

• 修改元素

  使用下标可以直接修改列表的元素

  Bf = ['张曼玉','林青霞','王祖贤','张曼玉']
  Bf[0] = '张国荣'
  print(Bf)
  #['张国荣', '林青霞', '王祖贤', '张曼玉']
  

• 复制

  copy()

  name_list = ['tom','jim','rose']
  name_123 = name_list.copy()
  print(name_123)
  #['tom', 'jim', 'rose']
  

• 排序

  sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

  语法

  list.sort( key=None, reverse=False)
  

  • key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

  实例

  aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
  aList.sort()
  print ( "List : ", aList)
  
  # List :  ['Facebook', 'Google', 'Runoob', 'Taobao']
  

列表的遍历

while

• 代码

  name_list = ['tom','jim','rose']
  i = 0
  while i<len(name_list):
      print(name_list[i])
      i += 1
  

for

• 代码

  name_list = ['tom','jim','rose']
  for i in name_list:
      print(i)
  

列表嵌套

• 代码

  name_list = [['小明，小红']，['Tom','Jim']]
  

元组(tuple)

元组和列表非常相似，但是元组一旦被初始化就不能修改，所有没有append（）、insert（）这样的方法

定义元组

• 代码

  #多个数据
  name_list = ('tom','jim','bill')
  
  #单个数据
  name_list = (1,)   
  

  注：定义单个元素的tuple，必须有 ’‘，’‘ 不然定义的不是tuple，是 1这个数

元组的常见操作

元组数据只支持查找，具体如下：

• 按下标查找

  tuple1 = ('aa','bb','cc')
  print(tuple1[0])    #aa
  

• index(): 查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串和index方法相同

  tuple1 = ('aa','bb','cc')
  print(tuple1.index('aa')) #0
  

• count(): 统计某个数据在当前元组的次数

  tuple1 = ('aa','bb','cc','aa')
  print(tuple1.count('aa')) #2
  

• len(): 统计元组中数据的个数

  tuple1 = ('aa','bb','cc','aa')
  print(len(tuple1)) #4
  

元组数据的修改操作

元组里面有list，修改list里面的数据是支持的

tuple2 = (10,20,['aa','bb','cc'],40,30)
print(tuple2)
tuple2[2][0] = 'aaa'
print(tuple2)
#(10, 20, ['aa', 'bb', 'cc'], 40, 30)
#(10, 20, ['aaa', 'bb', 'cc'], 40, 30)

字典（dict）

key-value存储方式 一个key只能对应一个value

定义字典

• 代码

  # 有数据字典
  dict1 = {'name':'Tom','age':20,'gender':'男'}
  
  #空字典
  dict2 = {}
  
  dict3 = dict()
  

字典常见操作

1、增

写法：字典序列[key] = 值

注：key存在即 修改key对应的值，key不存在则新增此键值对

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1)

dict1['name'] = 'Jim'
print(dict1)

dict1['id'] = 110
print(dict1)

#{'name': 'tom', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男', 'id': 110}

注：字典为可变类型

2、删

• del() / del:删除字典或删除字典中指定键值对

  dict1 = {'name':'tom','age':20,'gender':'男'}
  print(dict1)
  del  dict1['gender']
  print(dict1)
  
  #{'name': 'tom', 'age': 20, 'gender': '男'}
  #{'name': 'tom', 'age': 20}
  

• clear()：请空字典

  dict1 = {'name':'tom','age':20,'gender':'男'}
  dict1.clear()
  print(dict1)
  
  #{}
  

3、改

写法：字典序列[key] = 值

注：如果key存在则修改这个key对应的值，不存在则新增此键值对

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1)

dict1['name'] = 'Jim'
print(dict1)

dict1['id'] = 110
print(dict1)

#{'name': 'tom', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男'}
#{'name': 'Jim', 'age': 20, 'gender': '男', 'id': 110}

4、查

4.1 key值查找

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1['name'])	#tom
print(dict1['id'])		#报错

4.2 get()

• 语法

  字典序列.get(key,默认值)
  

注意：如果当前查找的key不存在则返回第二个参数值（默认值），如果省略第二个参数值，则返回None

• 代码

  dict1 = {'name':'tom','age':20,'gender':'男'}
  print(dict1.get('name'))
  print(dict1.get('id',-1))
  print(dict1.get('id'))
  
  # tom
  # -1
  # None
  

4.3 keys()

• 代码

  dict1 = {'name':'tom','age':20,'gender':'男'}
  print(dict1.keys())
  
  #dict_keys(['name', 'age', 'gender'])
  

4.4 values()

• 代码

dict1 = {'name':'tom','age':20,'gender':'男'}
print(dict1.values())

#dict_values(['tom', 20, '男'])

4.5 items()

• 代码

  dict1 = {'name':'tom','age':20,'gender':'男'}
  print(dict1.items())
  
  #dict_items([('name', 'tom'), ('age', 20), ('gender', '男')])
  

字典的循环遍历

语法 for…in….

遍历key

dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.keys():
    print(i)
   
# name
# age
# gender

遍历value

dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.values():
    print(i)
    
# tom
# 20
# 男

遍历字典的键值对

dict1 = {'name':'tom','age':20,'gender':'男'}
for i in dict1.items():
    print(i)
    
#('name', 'tom')
#('age', 20)
#('gender', '男')

集合(set)

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

注：创建空集合只能使用set(), 因为{}用来创建空字典

​ set不是有序的

创建集合

s1 = {10,20,30,40}
print(s1)

s2 = set('abcedfab')
print(s2)

s3 = set()
print(s3)

s4 = set([1,2,3,4,5])
print(s3)

# {40, 10, 20, 30}
# {'f', 'a', 'c', 'b', 'e', 'd'}
# set()
{1, 2, 3, 4, 5}

增加数据

---

• add()

  s1 = {10,20}
  s1.add(100)
  print(s1)
  s1.add(10)
  print(s1)
  
  #{100, 10, 20}
  #{100, 10, 20}
  

集合有去重功能，重复添加无效、且集合无序

• update(),追加的数据是序列

序列类型包括字符串、列表、元组、集合和字典

​

s1 = {1,2,3,4}
s1.update('abcdef')
print(s1)

# {'b', 1, 2, 3, 4, 'd', 'c', 'e', 'f', 'a'}

删除数据

---

• remove(), 删除集合中指定元素，元素不存在则报错

  s1 = {2,3,4,5}
  s1.remove(3)
  print(s1)
  
  # {2, 4, 5}
  

• discard(), 删除集合中的指定元素，元素不存在不报错

  s1 = {2,3,4,5}
  s1.discard(6)
  

• pop(), 随机删除集合中的某个元素，并返回该元素

  s1 = {2,3,4,5}
  print(s1.pop())
  print(s1)
  
  # 2
  # {3, 4, 5}
  
  

查找元素

---

• in：判断元素在集合序列

• not in：判断元素不在集合序列

  s1 = {'a','b','c','d'}
  print('a' in s1)
  print('e' not in s1 )
  
  # True
  # True
  

公共的方法

一、运算符

---

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

二、公共方法

函数	描述
len()	计算容器中元素的个数
del() 或del+空格	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start,end,step)	生成从start到end的数字，步长为step，供for循环使用
enumerate()	函数用于将一个可便利的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用于 for 循环当中

• del /del()

  s1 = [1,2,3]
  s2 = [4,5,6]
  del s1
  
  del(s2)
  
  

• range()

  for i in range(1,10):
      print(i,end=' ')
  # 1 2 3 4 5 6 7 8 9 
  
  for i in range(1,10,2):
      print(i,end=' ')
  # 1 3 5 7 9 
  
  for i in range(10):
      print(i,end=' ')
  
  # 0 1 2 3 4 5 6 7 8 9 
  

• enumerate()

  1、语法

  enumerate(可遍历对象，start=0)
  

  注意：start参数用来设置遍历数据的下标的起始值，默认为0

  2、代码

  list1 = ['a','b','c','d']
  for i in enumerate(list1):
      print(i)
  
  for index,char in enumerate(list1,start=1):
      print(index,char)
      
  # (0, 'a')
  # (1, 'b')
  # (2, 'c')
  # (3, 'd')
  
  # 1 a
  # 2 b
  # 3 c
  # 4 d
  

函数

在python里的变量，函数和模块名使用下划线连接；类名使用大驼峰命名法

如：user_name_and_password

• 函数的作用：封装代码，高效的代码使用

• 函数使用步骤

  • 定义函数

    def 函数名():
        代码1
        代码2
        ...
    

  • 调用函数

    函数名
    

• 函数的参数：函数调用的时候可以传入真实数据，增大函数使用的灵活性

  • 形参：函数定义时书写的参数（非真实数据）
  • 实参：函数调用时书写的参数（真实数据）

• 函数的返回值

  • 作用：函数调用后，返回需要的计算结果

  • 写法

    return 表达式
    

• 函数的说明文档

  • 作用：保存函数解释说明的信息

  • 写法

    def 函数名()
    	""" 函数说明文档 """"
    

• 函数嵌套调用：一个函数内部嵌套调用另一个函数

函数的提高

变量作用域

---

变量作用域指变量生效的范围，主要分为两类：局部变量和全局变量

• 局部变量

定义在函数内部的变量，即只在函数内部生效

def testA():
    a = 1
    print(a)

testA() #1
testA(a) #NameError: name 'a' is not defined

变量a是定义在 test函数 内部的变量，在函数外部访问则立即报错

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

• 全部变量

在函数体内、外都能生效的变量

#定义全局变量a
a = 100
def testA():
    print(a)

def testB():
    print(a)
testA() #100
testB() #100

• 在函数体内部修改全局变量

  a = 100
  def testA():
      print(a)
  
  def testB():
      # global 关键字声明a是全局变量
      global a
      a = 200
      print(a)
  testA() 
  testB() 
  print(f'全局变量a = {a}')
  
  # 100
  # 200
  # 全局变量a = 200
  

多函数程序执行流程

---

• 公用全局变量

  # 1、定义全局变量
  gol_num = 0
  
  def test1():
      global gol_num
      # 修改全局变量
      gol_num = 99
  
  
  def test2():
      # 调用test1函数中修改后的全局变量
      print(gol_num)
  
  # 2、调用test1函数，执行函数内部代码：声明和修改全局变量
  test1()
  # 3、调用test2函数、执行函数内部代码，打印
  test2() #100
  

• 返回值作为参数传递

  def test1():
      return 99
      
  def test2(num):
      print(num)
  
  test2(test1())
  

函数的返回值

---

• 一个函数返回多个函数值

def return_num():
    return 1,2

result = return_num()
print(return_num())

#(1, 2)

注意：

1、return a ，b 写法，返回多个数据时，默认为元组

2、return后面可以连接列表、元组或者字典，以返回多个值

函数的参数

---

位置参数

---

位置参数：调用函数时根据函数定义的参数位置来传递函数

def user_info(name,age,gender):
   print(f'您的名字是{name},年龄{age},性别是{gender}')

user_info('Tom',18,'男')

#您的名字是Tom,年龄18,性别是男

注意：传递和定义参数的顺序及个数必须一致

关键字参数

---

函数调用，通过“key = value”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name,age,gender):
   print(f'您的名字是{name},年龄{age},性别是{gender}')
   
user_info(name='王祖贤',gender='女',age=20)

# 您的名字是王祖贤,年龄20,性别是女

注意：函数调用时，如果有位置参数时，位置参数必须在关键字的前面，但关键字参数之间不存在先后顺序

缺省参数

---

缺省参数也叫默认参数，用于定义函数，为函数提供默认值，调用函数时可不传该默认参数的值（注：所有位置参数必须在默认参数前，包括函数定义和调用）

def user_data(name,age,gender = '男'):
    print(f'你的名字是{name},年龄是{age},性别是{gender}')

user_data('Tom',30)
user_data('王祖贤',20,'女')

# 你的名字是Tom,年龄是30,性别是男
# 你的名字是王祖贤,年龄是20,性别是女

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用该函数值

不定长参数

---

不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。此时，可用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

• 包裹位置参数

def user_info(*args):
    print(args)         #args不是固定形参，是常用

user_info('Tom')
user_info('Tom',18,'王祖贤')
# ('Tom',)
# ('Tom', 18, '王祖贤')

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型，这就是包裹位置传递。

• 包裹关键字传递

def user_info(**kwargs):
    print(kwargs)

user_info(name='tom',age=20,gender='男')

#{'name': 'tom', 'age': 20, 'gender': '男'}

综上，无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

拆包和交换变量值

---

拆包

---

• 拆包：元组

  def return_num():
      return 300,400
  
  
  num1, num2 = return_num()
  print(num1) #	300
  print(num2) #   400     
  

• 拆包：字典

交换变换量值

---

需求：交换a ，b两个变量的值

• 方法一

借助第三方变量存储数据

a = 10
b = 20
c = a
a = b
b = c

print(a) #20
print(b) #10

• 方法二

a,b = 1,2
a,b = b,a
print(a) #2
print(b) #1

引用

---

了解引用

---

在python中，值是靠引用来传递来的。

我们可以用id()来判断两个变量是否为一个值的引用。我们可以将id值理解为那块内存的地址标识。

• int类型

a = 1
b = a 
print(b) #1
print(id(a)) #2202015263024
print(id(b)) #2202015263024
a = 2
print(b) #1 ,说明int类型是不可变类型
print(id(a)) #2202015263056
print(id(b)) #2202015263024

• list类型

aa = [10,20]
bb = aa
print(id(aa)) #1612505953280
print(id(bb)) #1612505953280
aa.append(30)
print(bb) #[10, 20, 30]，列表为可变类型
print(id(aa)) #1612505953280
print(id(bb)) #1612505953280

引用当做实参

---

代码如下：

def test1(a):
    print(a)
    print(id(a))

    a += a

    print(a)
    print(id(a))
#int:计算前后id不同	
b = 100
test1(b)
#list：计算前后id相同
c = [10,20]
test1(c)

结果如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OvZUZhAu-1617806463940)(C:\Users\86182\AppData\Roaming\Typora\typora-user-images\image-20210325145406398.png)]

可变和不可变类型

---

数据能够直接修改是可变类型，不可修改的是不可变类型

即：地址是否改变，改变的是不可变

• 可变类型
  • 列表
  • 字典
  • 集合
• 不可变类型
  • 整型
  • 浮点型
  • 字符串
  • 元组

lambda表达式

lambda也是一个匿名函数

lambda的应用场景

---

如果一个函数有一个返回值，并且只有一句代码，可以用lambada简化

lambda语法

---

lambda 参数列表：表达式

注意

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
• lambda表达式能接受任何数量的参数但只能返回一个表达式的值

def fnl():
    return 100
print(fnl())

#lambda实际也是一个匿名函数
fnl1 = lambda:100
print(fnl1)
print(fnl1())

#100
#  at 0x0000020BD25EA310>
# 100

直接打印lambda表达式，输出的是内存地址

示例：计算a + b

---

1、函数实现

def add(a,b):
    return a,b
print(add(1,2))

2、lambda实现

fnl = lambda a, b:a + b
print(fnl(1,2))

lambda的参数形式

---

1、无参数

fn0 = lambda: 100
print(fn0())

2、一个参数

fn1 = lambda a: a
print(fn1(1))

3、默认参数

fn2 = lambda a, b, c = 100: a + b + c
print(fn2(100,100))

4、可变参数：*args

fn3 = lambda *args: args
print(fn3(1,2,3,4,5))
#生成元组

5、可变参数：**kwargs

fn4 = lambda **kwargs: kwargs
print(fn4(name = 'tom',age = 20))
#生成字典

lambda的应用

---

1、带判断的lambda

fnl = lambda a,b:a if a > b else b
print(fnl(10,20))
# 20

2、列表数据按字典key的值排序

students = [{'name':'Tom','age':18},{'name':'jim','age':19}, {'name': 'Rose', 'age':20}]

#按age值升序排列
students.sort(key=lambda x:x['age'])
print(students)

#按age值降序排列
students.sort(key=lambda x:x['age'],reverse=True)
print(students)

高阶函数

把函数当作参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式

体验高阶函数

---

• abs()函数

  可以对数字求绝对值计算

  abs(-10) #10
  

• round()函数

  可以对数字完成四舍五入计算

  print.(round(1.2)) #1
  print.(round(1.9)) #2
  

例子：对两个数进行加法

def sum_num(a,b,f):
    return f(a)+f(b)
print(sum_num(3,-3,abs))
#6

内置的高阶函数

---

1、map()

map(func,lst),将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的迭代器返回

例子：计算list1序列中各个数字的二次方

def func(x):
    return x ** 2
list1 = [1,2,3,4]
result = map(func,list1)
print(result)
print(list(result))
 
# 
# [1, 4, 9, 16]

2、reduce()

reduce(func,lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算

注意：reduce()传入的参数func必须接收两个参数

例子：计算list1序列中各个数字的累加和

 import functools
 list1 = [1,2,3,4,5]
 def func(a,b):
     return a + b
result = functools.reduce(func,list1)
 print(result)
# 15

3、fileter()

fileter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以用list()来转换

list1 = [1,2,3,4,5,6,7,8]
def func(x):
    return x % 2 == 0
result = filter(func,list1)
print(result) # 
print(list(result)) #[2, 4, 6, 8] 

文件

文件备份

---

步骤

---

1、接受用户输入的文件名

2、规划备份文件名

3、备份文件写入数据

代码实现

---

1、接受用户输入目标文件名

old_name = input('请输入您要备份的文件名')

2、规划备份文件名

​ 2.1 提取目标文件后缀

​ 2.2 组织备份的文件名，xx[备份]后缀

# 2.1 提取文件后缀点的下标
index = old_name.rfind('.')

# 2.2 组织新文件名 旧文件名 + [备份] + 后缀
new_name = old_name[:idex] + '[备份]' + old_name[index:]

#打印新文件名 (带后缀)
print(new_name)

3、备份文件写入数据

​ 3.1 打开源文件 和 备份文件

​ 3.2 将源文件数据写入备份文件

​ 3.3 关闭文件

# 3.1 打开文件
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')

#3.2 将源文件数据写入备份文件
while True:
    con = old_f.read(1024)
    if len(con) == 0:
        break
        new_f.wirte(con)
        
# 3.3 关闭文件
old_f.close()
new_f.close()

—————————–

面向对象：

类和对象：

类和对象的关系：用类去创造一个对象

定义类：

• 语法

  class 类名():
      代码
      ......
  

  注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯

• 体验

  class User:
      def __init__(self,first_name,last_name,gender,age):
          self.first_name = first_name
          self.last_name = last_name
          self.gender = gender
          self.age = age
          self.login_attempts = 0
  
      def decribe_user(self):
        print(f"姓名{self.first_name}{self.last_name},年龄{self.age},性别{self.gender}")
  
      def greet_user(self):
          print('为您服务')
  
      def increment_login_attempts(self):
          self.login_attempts += 1
  
      def reset_login_attempts(self):
          self.login_attempts = 0
  
      def print_login_attempts(self):
          print(f"{self.login_attempts}")
  

继承

父类必须包含在当前文件，且位于子类前面

• 代码

  class User:
      ......
      ......
      
      
  class Admin(User):
      def __init__(self,first_name,last_name,gender,age):
          super().__init__(first_name,last_name,gender,age)
          self.privileges = Privileges()
  

:
return a + b
result = functools.reduce(func,list1)
print(result)

15

#### 3、fileter()

fileter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以用list()来转换

```python
list1 = [1,2,3,4,5,6,7,8]
def func(x):
    return x % 2 == 0
result = filter(func,list1)
print(result) # 
print(list(result)) #[2, 4, 6, 8] 

文件

文件备份

---

步骤

---

1、接受用户输入的文件名

2、规划备份文件名

3、备份文件写入数据

代码实现

---

1、接受用户输入目标文件名

old_name = input('请输入您要备份的文件名')

2、规划备份文件名

​ 2.1 提取目标文件后缀

​ 2.2 组织备份的文件名，xx[备份]后缀

# 2.1 提取文件后缀点的下标
index = old_name.rfind('.')

# 2.2 组织新文件名 旧文件名 + [备份] + 后缀
new_name = old_name[:idex] + '[备份]' + old_name[index:]

#打印新文件名 (带后缀)
print(new_name)

3、备份文件写入数据

​ 3.1 打开源文件 和 备份文件

​ 3.2 将源文件数据写入备份文件

​ 3.3 关闭文件

# 3.1 打开文件
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')

#3.2 将源文件数据写入备份文件
while True:
    con = old_f.read(1024)
    if len(con) == 0:
        break
        new_f.wirte(con)
        
# 3.3 关闭文件
old_f.close()
new_f.close()

—————————–

面向对象：

类和对象：

类和对象的关系：用类去创造一个对象

定义类：

• 语法

  class 类名():
      代码
      ......
  

  注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯

• 体验

  class User:
      def __init__(self,first_name,last_name,gender,age):
          self.first_name = first_name
          self.last_name = last_name
          self.gender = gender
          self.age = age
          self.login_attempts = 0
  
      def decribe_user(self):
        print(f"姓名{self.first_name}{self.last_name},年龄{self.age},性别{self.gender}")
  
      def greet_user(self):
          print('为您服务')
  
      def increment_login_attempts(self):
          self.login_attempts += 1
  
      def reset_login_attempts(self):
          self.login_attempts = 0
  
      def print_login_attempts(self):
          print(f"{self.login_attempts}")
  

继承

父类必须包含在当前文件，且位于子类前面

• 代码

  class User:
      ......
      ......
      
      
  class Admin(User):
      def __init__(self,first_name,last_name,gender,age):
          super().__init__(first_name,last_name,gender,age)
          self.privileges = Privileges()