乐愚社区Beta

 Python  >  python基础知识总结,人生苦短,我用python

python基础知识总结,人生苦短,我用python

旁观者  L21  • 2021-06-21 • 回复 2 • 查看 374 • 收藏 14 • 只看楼主举报    

前言

Python 是一种易于学习又功能强大的编程语言。它提供了高效的高级数据结构,还能简单有效地面向对象编程。Python 优雅的语法和动态类型,以及解释型语言的本质,使它成为多数平台上写脚本和快速开发应用的理想语言。

Python 解释器及丰富的标准库,提供了适用于各个主要系统平台的源码或机器码,这些可以到 Python 官网 https://www.python.org/ 免费获取,并可自由地分发。许多免费的第三方 Python 模块、程序、工具和它们的文档,也能在这个网站上找到对应内容或链接。

Python 解释器易于扩展,可以使用 C 或 C++(或者其他可以通过 C 调用的语言)扩展新的功能和数据类型。Python 也可用于可定制化软件中的扩展程序语言。

注释

注释  注释能够让阅读代码的人更加清晰的知道代码的作用, 注释可以增强代码的阅读性
 单行注释, 多行注释,
 在Python里面 # 号就代表单行注释
 多行注释
"""
这是多汗注释, 按住shift+"(连按三次")就可以出现多行注释
"""

数据类型

  1. int 数字整数
  2. Float 浮点类型(小数点)
  3. Bool 布尔类型(True(真, 1), False(假, 0))
  4. String 字符串 (带引号的都是字符串)
  5. List 列表
  6. Tuple 元祖
  7. Dictionary 字典

Python3 的数据类型中:

不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

变量名

变量名:字母、数字、下划线组成,数字不能开头,变量命名要和实际数据相关联(见名知意)
不能使用关键字命名
两种命名法:
1.大驼峰法命名:每一个单词的首字母大写 My_Name=
2.小驼峰法命名:除了第一个单词的字母以外,其他单词的首字母都要大写 my_Name_Is=

数值类型

整数

# 整型:整数
num_i_1 = 88    # i为int的缩写  int(整型)
num_i_2 = 66
print(num_i_1)
print('能给我发个%d的红包么?' % num_i_1)  # %为占位符 %d为十进制
print('能给我发个%o的红包么?' % num_i_1)   # %o为八进制
print('能给我发个%x的红包么?' % num_i_1)   # %x为十六进制
print('能给我发个%d的红包么或者%d的红包' % (num_i_1, num_i_2))

浮点数

# float浮点数
num_f_1 = 1.68888888
print(num_f_1)
print('能给我发个%f的红包么?' % num_f_1)    # 格式化输出浮点数型 默认保留小数点后6位
print('能给我发个%.3f的红包么?' % num_f_1)  # 小数点加数字 表示保留小数点后三位数字

布尔型

True=1
type(True)
输出:class'bool'

False=0
type(False)
输出:class'bool'

复数 a+bi

complex_1 = complex(1, 2) # 1为a 2为b

字符串

# 字符串
str_1 = 'good morning'
str_2 = 'good afternoon'
str_3 = 'good night'
print('%s,你吃了么' % str_1)
print('{},你吃了么' .format(str_2))
print(f'{str_3},你吃了么')
print('{},{},你吃了么'.format(str_1, str_2))

替换 replace

str_4 = 'play football'
print(str_4)
print(str_4.replace('football', 'basketball'))   # 前面是被替换的字符 后面是替换的新字符

strip去掉

# 两端去空白(做爬虫 做自动化处理Excel) strip(去掉  \t横向制表符  \n换行)
str_5 = '\tplay football\n'
print(str_5)
print(str_5.strip())

切割split

# 切割 (做爬虫 做自动化处理Excel) split
str_6 = 'go to school'
list_7 = str_6.split('o')
print(list_7)
print(type(list_7))

拼接 join

print('-'.join(str_6))
print('o'.join(list_7))

字符串大小写转化

# 字符串大小写转化  upper转化成大写 lower转化成小写
str_8 = 'day day up'
print(str_8.upper())
print(str_8.lower())

查找与统计

print(len(str_8))   # len()统计括号内输入的数据长度
print(len('@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@'))

count 统计

# count 统计字符出现的次数
print(str_8.count('a'))
print(str_8.count('d'))

find 查找

# find 查找字符是否在字符串中 返回第一次找到字母的下标
print(str_8.find('u'))  # 可以分区域查找(不给定区域就是查找整个字符串),如果不在返回-1
print(str_8.index('y', 3, 8))   # 可以分区域查找 index:类似find如果不在就会报错
# rfind:和find一样,不过是从右边开始查找
print(str_8.rfind('u'))
print(str_8.rindex('y', 3, 8))

判断与检测

# 判断
str_9 = '166529822545'
str_10 = 'adwfvhgcgajfkg'
print(str_9.isdigit())  # isdigit()判断括号内数据全为数字
print(str_10.isalpha()) # isalpha()判断括号内数据全为字母
# 检测  type()
num_1 = 141651
print(type(num_1))
str_11 = '168'
print(type(str_11))
list_1 = [1, 6, 8]
print(type(list_1))
tuple_1 = (1, 6, 8)
print(type(tuple_1))
dict_1 = {'1': 1, '6': 6, '8': 8}
print(type(dict_1))
set_1 = {1, 6, 8}
print(type(set_1))

强制转型

num_f_1 = float(num_1)
print(num_1)
print(num_f_1)
str_12 = str(num_1)
print(num_1)
print(type(num_1))
print(str_12)
print(type(str_12))

运算符

# 运算符

# 算数运算符
 加号  +
 减号  -
 乘号  *
 除法  /
 取整数  //
 取余数  %
 幂次方  **


# 比较(关系)运算符
 ==   检查两个参数是否相等 , 条件成立返回True
 !=    检查两个参数是否不相等 , 条件成立返回True
 > 大于号  左边数大于右边数就返回True
 < 小于号
 >= 大于等于
 <= 小于等于


 num_1 = int(input('请输入一个数字:'))
 num_2 = int(input('请输入一个数字:'))
 print(num_1 >= num_2)


# 逻辑运算符
 and  与   x and y    x和y都满足才返回True, 如果其中一个不满足就返回False
 or   或者   x or y   x和y有一个满足就满足, 如果都不满足才返回False
 not  不    如果x为True就返回False, 如果x为False就返回True


# 赋值运算符
 在Python中,使用=号可以给变量赋值
 +=  c = c + b  可简写为  c += b
 -=  c = c - b  可简写为  c -=b
 *=  c = c + b  可简写为  c *= b
 /=  c = c + b  可简写为  c /= b
 //=  c = c + b  可简写为  c //= b
 %=  c = c + b  可简写为  c %= b
 **=  c = c + b  可简写为  c **= b

 c = 0
 a = 1
 b = 2
 a = a + b
 a += b

# 运算符的优先级
 **   最高优先级
  *  /  %   //
 + -
 <= <  > >=
 ==   !=
 =  %=  /=   //=  -=  +=  *=  **=
 not or and    最低优先级


# 常用的数据类型转换

a = int(input('输入一个数字:'))
a = hex(a)
print(a)


c = 2
c = str(c)
c = float(c)
c = int(c)
print(c)

判断语句 if

# 判断语句, 给定一个条件, 如果在程序执行过程中判断该条件是否成立,根据判断结果执行不同的操作, 从而改变代码的执行顺序

 if 今天发工资:
     先还信用卡
     if 有剩余:
         还花呗
     else:
         没钱了, 什么也干不了
 else:
     等待发工资

 按住tab键也可以缩进, 一个缩进等于4个空格, tab和空格不要混合使用
 if (要判断的条件):
     条件成立,就执行

 age = int(input('请输入你的年龄:'))
 判断年龄是否大于等于18岁
 if age >= 18:
     print('可以进网吧嗨皮')
 else:
     print('没有成年,不能进网吧上网')

 else 处理条件不满足时的情况

if的嵌套使用

# if的嵌套使用
# if嵌套的应用场景, 在之前条件满足的前提下, 再增加额外的判断
 if 条件1:
     条件1满足执行的代码
     if 在条件1的满足的基础上加条件2:
         条件2满足时,执行的代码

     else:
         条件2不满足执行的代码
 else:
     条件1不满足时执行的代码

if 语句的进阶

# if 语句的进阶 elif, 条件不同, 需要执行的代码也不同, 就要用到elif,多层条件判断

 if 条件1:
     条件1满足时执行的代码

 elif 条件2:
     条件2满足时执行的代码

 elif 条件3:
     条件3满足时执行的代码

 else:
     以上条件都不满足时执行的代码

elif的实例

 holiday_name = input('今天是什么节日:')


 if holiday_name == '情人节':
     print('买玫瑰花')
     print('看电影')
     udyima = int(input('输入0代表False, 输入1代表True:'))
     if udyima == 0:
         print('这几天不方便,不能去儒家')
     elif udyima == 1:
         print('哈哈....可以去儒家啦!!! 好开心')
     else:
         print('唉...女人的心思真难懂!!!!!!')

 elif holiday_name == '圣诞节':
     print('吃圣诞大餐')
     print('送礼物')
     print('看电影')
     print('去儒家')

 elif holiday_name == '生日':
     print('送生日蛋糕')
     print('送礼物')
     print('看电影')
     print('去儒家')

 else:
     print('啊!!!今天终于不过节啦! 不用去儒家啦! 好累啊!! 要补补啦!!!')

while循环

# 定义一个计数器
 i = 1

 while i <= 100:  # 当条件满足时, while里面的代码才会执行
     print('I Love You')     # 需要重复执行的代码

     i += 1  # 一定要有计数器, 没有计数器很可能会造成死循环


# 程序的三大流程
# 在程序开发中,一共有三种流程
# 1. 顺序-- 从上往下, 按照顺序执行代码
# 2. 分支-- 根据条件判断, 决定执行代码的分支
# 3. 循环-- 让特定的代码重复执行

# 死循环, 由于程序员的原因, 忘记在循环内部修改循环的判断条件, 导致循环持续执行,程序无法终止

# Python中的计数(程序): 从0开始计数
# 自然计数是从1开始计数的


# 计算0-100之间所有的数字累计求和
# 0+1+2+3+4+5+6+7+8+9.....+100


# 计算0-100之间所有偶数的求和
# 定义一个计数器
 i = 0  # i是计数器
 s = 0   # s 是存储结果的容器

 while i <= 100:  # 当条件满足时, while里面的代码才会执行
     # print('I Love You')     # 需要重复执行的代码

     if i % 2 != 0:
         s += i

     i += 1  # 一定要有计数器, 没有计数器很可能会造成死循环

 print(i)
 print(s)


# break , continue是专门在循环中使用的关键字, 只在当前所在的循环有效

# break满足条件时, 退出循环, 不再执行后面重复的代码
# continue满足条件时, 跳过当前循环进入下次循环


 i = 0

 while i < 10:
     if i == 7:
         i += 1
         continue
     print(i)
     i += 1

# while嵌套就是while里面嵌套while
# 外部的while影响内部while循环的运行, 直至内部循环不满足条件时才会继续执行外部循环

for 循环

# for 循环
# 在Python中for循环可以遍历任何序列的项目, 比如一个列表或者以个字符等

# for循环的格式
# for 临时变量 in 列表或者字符等:
#     循环满足条件的时候需要执行的代码
# else:
#     执行不满足条件的代码

 str_1 = '123456789'

 for i in str_1:
     if i == '8':
         continue
     print(i)
 else:
     print('当字符串里面的所有内容被遍历完之后,条件就不满足了, 就会执行else')

 # range 是范围的意思
 for i in range(1, 3):
     for j in range(1, 3):
         for s in range(1, 3):
             print(i, j, s)

列表

# 列表 :中括号
 a = 'xiaoming'
 list_1 = []
 list_2 = list()
 list_3 = ['xiaohong', 'lisi']
# 增:往列表里面添加数据
# append  往末尾添加
 list_3.append('zhangfei')
 print(list_3)

# insert
 list_3.insert(0, 'machao')
 print(list_3)

 b = ['liubei', 'zhaoyun']
 list_3.extend(b)
 print(list_3)
 a = [1, 2, 3, 4, 5, 6, 7, 8]
 b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

 for i in a:
     b.insert(i, a[i-1])
 print(b)


# 根据下标取列表中得元素(注意点:下标是从0开始得)
 print(b[2])
 print(b[3])
 print(b[4])

# 左闭右开,依次取值
 print(b[2:4])
 print(b[2:6])
 print(b[2:8])

 ['c', 'd', 'e', 'f', 'g', 'h']
# 根据步长依次递增选取
# 下标0, 2, 4, 6, 8
 print(b[2:8:2])
# 下标0, 3, 6, 9
 print(b[2:8:3])
# 下标0, 4, 8, 12
 print(b[2:8:4])

 b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

 print(b[-4:])
 print(b[:-4])

# 删除remove
 b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
 print(b.remove(b[0]))
 b.remove(b[0])
 print(b)
 del b[0]
 print(b)


# 删除最后一个值
 a = b.pop()
 print(a)
 b[3][0] = 'zhangfei'
 print(b)
 a = b.pop(3)
 print(a)

# 修改,根据=赋值
 b = [['xiaoming', 18, '男'], ['xiao红', 18, '女'], ['李四', 18, '男'], ['张飞', 18, '男']]
 c = b[2][0].replace('李四', 'lisi')
 print(b)
 b = 888
 c = 889-1
 print(id(b))
 print(id(c))
# is == 区别

# 查 index, in, not in

 print(len(b))
 if '3' in b:
     num = b.index('3')
     print(num)
 for i in b:
     print(i)
 a = 'qwertyuiasdfgasfsafafsafasfafsafafhjkzxcvbnm'
 num = len(a)
 print(num)

 for j in b:
     print(b.index(j))
       print(j)
       str_1 = b[j]
       print(str_1)

 b = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', '3']
 i = 0
# 长度为9,有9个数据
 print(len(b))

 while i < len(b):
     print(b[i])
     i = i + 1

元组

# 元组:不可变得数据类型  小括号
# 当元组里面只有一个值得时候,需要在后面加一个,
 a = tuple()
 b = (2,)

 print(type(a))
 print(type(b))

 a = (1, 2, 3, 4, 5)
 b = list(a)
 b[0] = 'g'
 c = tuple(b)
 print(c)


 a = ('a', 'b', 'c', 'd', 'd', 'e', 'e')
 print(a.index('b'))

 print(a.count('d'))

字典

# 字典:外面是大括号
# 键值对的形式存在
# 什么是键值对   key:value
# c = {'key': 'value'}


 a = {'name': 'xiaoming'}
 b = dict()

# 添加
 a['age'] = 20
 print(a)
 a = {'name': 'xiaoming', 'age': 20}
 a['age'] = 18
 print(a)

# 结论:往字典里面添加数据,key值存在,则修改,不存在就创建

 c = str_1.split('; ')
 print(c)
# 字典推导式
 result = {i.split('=')[0]: i.split('=')[1] for i in str_1.split('; ')}
 print(result)
 a = {}
 for i in str_1.split('; '):
     i.split('=')

 a = 'xiaoming 20 男'
 b = a.split(' ')
 print(b)
 print(str_1.split('; '))

# 字典的删除操作

 del a['name']
 print(a)
 a.clear()
 print(a)

 for i in a.values():
     print(i)
 print('*********************************')
 for j in a.keys():
     print(j)

 print(a.items())
 for i in a.items():
     for j in i:
         print(j)
 for i in a.keys():
     print(i)

     a['name'] = 'name' + '1'
 print(a)
 a = {'name': 'xiaoming', 'age': 20, 'sex': '男', 'number': 0}
 in
 not in

 a = {'name': 'xiaoming', 'age': 20, 'sex': '男', 'number': 0}
 for i in a.keys():
     if 'name' in i:
         print(6666666666)
     if 'name' not in i:
         print(8888888888)

集合

# 集合, 最外面是大括号
# 特征:去重,集合是无序的,不支持下标(索引)的操作
 a = set()
 b = {1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 5, 5, 5, 1, 1, 1, 1}
 print(b)

# 应用场景:爬虫的url(网址,链接)地址去重
# 添加元素
 a.add('xiaoming')
 a.add('18')
 print(a)

 b.remove(6)
 print(b)

# 嵌套
 a = [[{'name': 'x', 'age': 18, 'sex': '男'}], [{'name': 'y', 'age': 18, 'sex': '男'}], [{'name': 'z', 'age': 18, 'sex': '男'}]]

 print(type(a[0]))
# 非常注意的地方集合和字典不能同时存在
 a = {{'name': 'xiaoming'}}
 print(a)

 a = [[{'name': 'x', 'age': 20, 'sex': '男'}, {'name': 'a', 'age': 21, 'sex': '男'}],
      [{'name': 'y', 'age': 19, 'sex': '男'}, {'name': 'b', 'age': 22, 'sex': '男'}],
      [{'name': 'z', 'age': 18, 'sex': '男'}, {'name': 'c', 'age': 23, 'sex': '男'}]]
 print(a[1])
 print(a[1][0])
 print(a[1][0]['name'])

 print(a[2][1]['age'])

 a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 j = 0
 for i in a:
     j += i
 print(j)
 print(sum(a))

运算符公共方法

"""运算符公共方法"""
# +          支持:字符串,列表,元组,不同数据类型不支持相加
 a = 'zhang'
 b = 'fei'
 c = b + a
 print(c)
 aa = '1'
 bb = '2'
 cc = aa + bb
 print(cc)
 #对于数字是加,  对于字符是拼接
 a = (1, 2, 3, 4, 5, 6)
 b = ['a', 'b', 'c']
 print(a + b)
 a = {'name': 'xiaoming'}
 b = {'age': 18}
 print(a + b)


# *         支持:字符串, 列表,元组
 a = 2
 print(a ** 3)
 a = 'qwertyuio'
 print(a * 2)
 b = [1, 2, 3]
 print(b * 2)
 c = {1, 2, 3}
 print(c * 2)

 # in         支持:字符串,元组,列表,字典,集合
 a = [1, 2, 3, 4, 5, 8]
 if 1 in a:
     print(666)
 a = {'name': 'xiaoming', 'age': 18}

in 对字典操作

'''注意:in 对字典操作时,默认判断的是字典的key值'''
 if {'name': 'xiaoming'} in a:
     print(666)
 else:
     print(888)
 a = (1, 2, 3, ('a', 'b', 'c'))
 b = ('a', 'b', 'c')
 if b in a:
     print(666)
 else:
     print(888)

# 字典和集合不能共存
 a = {'key': ({'name': 'xiaoming'}, {'name': 'xiaoming'}), 'keys': {'age': 18}}
 b = 'name'
# 并不是判断a字典所有key
 if b in a.keys():
     print(666)
 else:
     print(888)


# not in     支持:字符串,元组,列表,字典,集合
 a = {1, 2, 3}
 b = 3
 if b in a:
     print(666)
 else:
     print(888)
 a = {{'name': 'xiaoming'}}
 print(a)

python内置函数

"""python内置函数"""
# len       统计元素(数据)个数
 a = (1, 2, 3, 4, 2)
 print(len(a))

# max       返回容器中最大值
 a = ['b', 'f', 'e', '2']
 b = max(a)
 print(b)
# min       返回容器中最小值
 a = ['b', 'f', 'e', '2']
 b = min(a)
 print(b)

# del       删除

# sum       求和
 a = [1, 2, 3, 4, 5, 7]
 b = sum(a)
 print(b)

可变类型与不可变类型

"""引用:可变类型与不可变类型"""
# 改变数据结构,内存地址是否会发生变化

# is 和 == 的区别?

 a = 999
 b = 1000 - 1
 if a is b:
     print(666)
 if a == b:
     print(888)
# is 是判断二者的内存空间知否相同
#  == 是判断二者的值是否相等



# 往列表, 字典里面添加数据,是不改变内存空间的,即是可变数据类型
 list_1 = [1, 2, 3, 4, 5]
 print(id(list_1))
 list_1.append('f')
 print(id(list_1))

 a = {'name': 'xiaoming'}
 print(id(a))
 a['age'] = 18
 print(id(a))

# 不可变类型:字符串,元组:改变其结构,会产生一个新的数据
 a = 'xiao'
 print(id(a))
 print(id(a + 'sdsad'))
 b = (1, 2, 3)
 c = (1, 2, 3)
 print(id(b))
 print(id(c))
 a = ['xiaomin', '女']
# 不可变数据类型:存储帐号信息,银行卡信息,密码信息,密钥等等
# 可变数据类型:个人信息

三目运算符:三元表达式

"""三目运算符:三元表达式"""
# 返回True执行 if 表达式 else 返回False执行

 print('我在你心里' if 3 > 4 else '你不在我心里')


print(i for i in range(10) if i % 2 != 0 )

 list_1 = []
 for i in range(10):
     if i % 2 != 0:
         list_1.append(i)
     else:
         list_1.append('s')
 print(list_1)







 x = 3
 y = 5
# 执行顺序:从左往右执行
 print('我比你大' if x > y else '今天天气真好' if x == y else '今天下雨了')
 if x>y:
     print('我比你大')
 else:
     if x == y:
         print('今天天气真好')
     else:
         print('今天下雨了')
# 求证的问题:嵌套三目运算符执行顺序
# 从左到右 1 输出我比你大
# 从右到左 2 输出今天下雨

 a = 1
 b = 2
 print('你真棒'if a > b else '很尴尬' if a == b else '哭了' if a < b else '赢了')
 if a > b:
     print('你真棒')
 else:
     if a == b:
         print('很尴尬')
     else:
         if a < b:
             print('哭了')
         else:
             print('赢了')

函数

函数的使用

#函数的使用
# 1)函数的定义
# def 函数名():   #函数名命名:字母_数字_下划线且数字不能开头(见名知义),大_小驼峰法
#     实现独立功能的代码块1
#     ...
#     实现独立功能的代码块2
#定义好之后,不调用不会去运行


# 2)函数的调用:直接使用函数名()  #方法的调用:通过变量点方法,list_2.append((x, y))
# FoZu()  #代码运行跳转到函数定义

函数的返回值

#函数的返回值
def sum_1():
    a = 1
    b = 2
    c = a+b
    return c  #停止函数运行,return返回函数运行结果(多种数据类型)


# print(sum_1())  #直接打印为None,需要sum_1 = 3

函数的参数

#函数的参数:在定义函数实现功能代码中需要使用的变量
# def 函数名(参数1,参数2,...,参数n):
#     实现独立功能的代码块1
#     使用参数1
#     ...
#     使用参数2
#     实现独立功能的代码块2

def sum_2(a, b):
    return a+b

 print(sum_2(123456787654321,123456787654321))

#参数的性质:形参和实参
def sum_3(a, b):  #形参(形式参数):函数定义时使用的参数叫形参(占位符)
    return a+b

 print(sum_2(63,12345321))  #实参(实际参数):调用函数时实际传入的参数

#参数的类型:
#必须(位置)参数:在调用函数时必须使用的参数,与代码块定义的功能(参数位置出错,结果截然不同,甚至报错)
def division(a, b):  #division:除法
    return a/b


 print(division(1,3))


 print(division(1, 2))
 print(division(2, 1))


 print(division(1,0))
 print(division(0,2))

#默认参数:在函数定义时给定参数默认值,在调用函数时传入 新参数 就 更新 参数,不传入则使用定义时的默认值(遵循顺序引用参数)
def sum_4(a=1, b=2):
    return a+b

# num_1 = 67
num_1 = 23
 print(sum_4(4, 5))
 print(division())
 print(sum_4())  #不传参可直接使用

#只输入单个
 print(sum_4(66))


#必须参数和默认参数混用遵循顺序,定义和调用时默认参数在前。
def sun_6(a,b=1):
    pass

#关键字参数:在定义时和默认参数类似,以键值对的形式传入,不用去在意参数位置(顺序)
def sum_5(a=1, b=2):
    return a+b


 print(sum_5(a=3, b=7))
 print(sum_5(b=7, a=3))  #关键字参数使用时,带上关键字




#不定长参数:在定义的时候不确定传入参数的个数
def Func(*args, **kwargs):  #*代表个数不确定,*args使用元组接收参数,**kwargs:使用字典接收参数
    print(args)
    print(kwargs)

 Func(1, 2, 3, a=4, b=5, c=6)  #设计两种接收方式,为了解决多种参数传入

# 函数的类型:根据函数有无参数和返回值判断
# 有参数 有返回值  A
# 无参数 有返回值  B
# 有参数 无返回值  C
# 无参数 无返回值  D

函数的嵌套

#函数的嵌套:函数定义时调用其他函数
def sum_7():
    return 2+3

# print(sum_7())
def sum_8(d):
    return sum_7()*d

print(sum_8(5))

变量

#变量的作用域:在哪一部分程序可以访问哪个特定的变量
#全局变量:在代码文件中直接定义任何地方都可以引用的变量


# 局部变量:在某个特定的区域才能访问(明前学到:在函数内/在函数外),定义在函数内的变量只能在函数内访问
def sum_1():
    num_1 = 99
    print(num_1)
 sum_1()
 print(num_1)


#全局变量和局部变量重名:重名的局部变量不回去覆盖全局变量,优先使用局部变量(强龙不压地头蛇)
num_2 = 98
def sum_2():
    num_2 = 19
    print(num_2)
 sum_2()
 print(num_2)

#global:将局部变量修改为全局变量(蛇想要化龙)
def sum_3(a,b):
    global num_2  # 已修改
    num_2 = a+b
    print(num_2)

 sum_3(2,3)
 print(num_2)

递归(算法)函数

#递归(算法)函数:函数调用本身函数。(想要理解递归你就先要理解递归)
#一个问题?不断拆解成小问题?解决一个小问题?将整个问题解决
#从前有座山,山里有座庙,庙里有个老和尚在讲故事,讲的故事是什么?
# while True:
#     print('从前有座山,山里有座庙,庙里有个老和尚在讲故事,讲的故事是什么?')

#递归函数要求:
#1、必须有明确的结束条件(出口)不然就是一个死循环
#2、每进入一层递归时,问题规模都要比上一次小

#定义计算阶乘的函数   5! = 5 x 4 x 3 x 2 x 1
def factorial(num):
    i = 1
    result = 1
    while i < num:
        i += 1
        result *= i
    return result
# print(factorial(20))

#定义阶乘的递归函数
def factorial_2 (num):
    if num >= 1:
        result = num*factorial_2(num-1)
    else:
        result = 1
    return result
# print(factorial_2(5))
# 问题拆解:5! = 5 x 4 x 3 x 2 x 1
# 结果返回:return result = 1 x 2 x 3 x 4 x 5
#调用函数,num=5,符合num>=1的条件执行下面代码块
#调用阶乘函数,此时参数num = 5-1=4,符合num>=1的条件执行下面代码块
#再次调用阶乘函数,此时参数num = 4-1=3,符合num>=1的条件执行下面代码块
#再次调用阶乘函数,此时参数num = 3-1=2,符合num>=1的条件执行下面代码块
#再次调用阶乘函数,此时参数num = 2-1=1,符合num>=1的条件执行下面代码块
#再次调用阶乘函数,此时参数num = 1-1=0,不合符num>=1的条件执行else下的代码
'''五次函数调用处于同时运行状态'''
#执行return,else将result重置为1,将返回结果给上一层

匿名函数

#匿名函数:在定义函数时不在使用def关键字的形式去定义
def sum_99(a, b):
    return a+b
# print(sum_99(4,5))
# print(type(sum_99(2,3)))
#匿名函数名 = lambda 参数1,参数2:功能代码
sum_99_1 = lambda x, y : x+y
# print(sum_99_1(4, 5))

#匿名函数的嵌套
sum_99_99 = lambda num_1:(lambda num_2:num_1+num_2)
#嵌套匿名函数调用
number_1 = sum_99_99(4) #第一层调用
print(type(number_1))  #此时第一次调用的对象也变成了函数,number_1 = lambda 4,num_2:num_1+num_2
print(number_1(5))

def sum_num_1(num1):

    def sum_num_2(num2):  #函数嵌套的另一种方法,函数体内定义子函数
        return num1+num2

    return sum_num_2(5)

# print(sum_num_1(4))

sum_99_99 = lambda num_1:(lambda num_2:num_1+num_2)

python的设计思想之一:全面调用计算机功能

#python的设计思想之一:全面调用计算机功能
#文件操作:打开,读取,写入,关闭(为了减少内存资源的浪费)

#打开文件:open(),引号内输入路径
 file = open('test.txt','w',encoding='utf8')


#读取:read()
 file_str = file.read()
 print(file.read())

 file = open('test.txt','r',encoding='utf8')
#读取一行:readline
 print(file.readline())

#以行的形式读取整个文件并返回列表:realines
 print(file.readlines())

#写入:write()
 file.write('aaa')  #直接写入会覆盖原来的内容

#关闭:close()
 file.close()

#open('文件名','访问模式参数','编码格式'):访问模式的权限参数
# r 只读
# w 只写,如果文件不存在就会创建新文件,直接写入会覆盖原文件内容
# a 追加,如果文件不存在就会创建新文件,在文件末尾写入文件?文件指针
# rb/wb/ab(binary system):以二进制的方式对文件进行读取,写入,追加
# r+/w+/a+/rb+/wb+/ab+:将文件指针移动到开头




#文件指针:记录读取和输入的位置
#第一次打开文件,通常文件指针都会指向文件开始的位置
#执行read方法后,文件会移动到读取内容的末尾

 file = open('test.txt','r+',encoding='utf8')
 print(file.read())
 print(file.tell())  #检测当前文件指针所在位置
 print('*'*50)
 file.seek(10)  #更改文件指针位置,0代表最开始
 print(file.read())

#文件复制
 file = open('test.txt','r',encoding='utf8')
 file_str = file.read()
 file_1 = open('test1.txt','w',encoding='utf8')
 file_1.write(file_str)
 file.close()
 file_1.close()

异常处理

# 异常处理:python中专门用来处理程序中出现的错误和异常的功能,可以用于程序调试
# 异常:在程序运行是,python解释器遇到错误,停止运行并提示错误信息

# 语法错误:不符合规范
# 运行错误:程序复杂可能出现的错误
# 语义错误:在编程时,将需求转化为代码逻辑出错。运行结果与预料结果不一致


#属性错误(AttributeError):特性引用和赋值失败时会引发的错误
 tuple_1 = (1,2,3)
 tuple_1.append('7')

#名称错误(NameError):试图访问不存在变量
 print(a)

#IOError:文件不存在

#关键字错误(KeyError):使用了映射中不存在的关键字(键名)
 dict_1 = {'a':1,'b':2}
 print(dict_1['c'])

#值错误(ValueError):传给对象的参数类型不正确
 int('asdfgh')

#索引错误(IndexError):使用的索引不存在
 list_1 = [1,2,3]
 print(list_1[99])

#类型错误(TypeError):函数应用与错误的类型
 age = 18
 print('我的年龄是' + 18)


# 捕获异常:能够保证程序的稳定性和健壮性(鲁棒性:一个程序的负荷能力)
#单个异常捕捉
# try-except
 try:
     可能会出现异常的代码
 except:
     写入自定义提示信息
 try:
     age = 18
     print('我的年龄是' + 18)
 except TypeError:
     print('此处出现类型错误,在116-117')
 print('aaa')

#在编程过程中,无法预判所有的异常
#多种异常捕捉
 try:
     int('asdfghj')
     age = 18
     print('我的年龄是' + 18)
 except Exception as Error:   #给对象重命名,自定义名字(见名知义)
     print('这里出现异常,行号位125-127')
 try:
     int('asdfghj')
     age = 18
     print('我的年龄是' + 18)
 except:
     print('这里出现异常,行号位125-127')

# try-except-else-finally
 try:
     int('asdfghj')
     age = 18
     print('我的年龄是' + 18)
 except Exception as Error:   #给对象重命名(见名知义)
     print('这里出现异常,行号位125-127')
 else:
     print('没有异常我才打印')
 finally:
     print('不管上面有没有异常我都运行')

#异常的传递性:当函数/方法执行时出现异常,会将该异常传递给调用的一方
def sum_1():
    return 3/0
def sum_2():
    return 5*sum_1()
 sum_2()

#自定义异常抛出:raise
#要求用户输入密码,密码规则:长度必须大于六位(长度小于六位就抛出异常)
 def u_i_p():
     pwd = input('请输入不小于六位数的密码:')
     if len(pwd) >=6:
         return '密码输入符合规范'
     ex = Exception('密码长度不够六位')  #自定义异常
     raise ex  #自定义异常抛出

 try:
     print(u_i_p())
 except Exception as Error:
     print('发现错误:%s' % Error)
     u_pwd = u_i_p()


#with open:保证代码是否有调用关闭代码它都会调用.close()
#try-finally:很繁琐
 try:
     f = open('test1.txt','r')
     print(f.read())
 finally:
     print(1)
     f.close()
     f.read()

 with open('test1.txt','r') as f:
     print(f.read())

 print(f.read())

面向对象编程

#面向对象编程

#面向过程编程:在解决问题时,先分析出解决问题的步骤,再使用函数一步一步把步骤实现,最后依次调用函数
#面向过程有两个特点:过程化和模块化
#将需求分为两步
def print_1():
    print('面向过程第一步')

def print_2():
    print('面向过程第二步')

 print_1()
 print_2()

#面向对象编程:就是把面向过程编程进行一个封装(将函数封装成类)
#面向对象编程思维再解决问题时,会将问题拆分成一个一个对象,根据对象的职责来定义方法
#面向对象的三大特点时封装、继承、多态
class Print:
    def print_1(self):
        print('面向对象的方法一')

    def print_2(self):
        print('面向过程的方法二')

 print_ = Print()  #创建对象
 print_.print_1()  #调用方法

 a = ['asdfg']  #创建对象
 a.sort()  #调用方法


#要想学好面向对象编程:
# 了解类和对象的概念
#类:类是一群具有相同特征或者行为的事物的统称,是抽象的,无法直接使用 ?制造小车的图纸(有各种数据和制造方法)
#对象:由类创建出来的实物,由对象创建的类拥有类的特征和行为  ?小车

#特征:属性
#行为:方法


#定义类:
#1、类名:大驼峰命名法
#2、类的具体属性
#3、类的具体方法

# class 类名:
#
#     def 函数名(self):
#         pass  #具体功能代码

class Car:  #定义类
    car_brand = 'Benz'  #定义属性
    def move(self):  #方法
        print('一脚油门飙到两百码')

    def toot(self):  #方法
        print('车在鸣笛')

# 创建对象
 benz = Car()
 benz.move()


#函数和方法的区别:
#定义:定义的函数属于整个文件(顶格),在类中定义的函数叫方法属于这个类
#调用:函数调用直接使用函数名(),方法的调用对象名.方法名()


#__init__和self:
#__方法名__ 属于内置方法
#__init__ 初始化对象,对象被创建时胡自动调用
#self指实例对象本身,这个参数不需要输入(区分函数和方法的标识之一)
class Car_:  #定义类
    color = 'pink'  #定义类属性
    def __init__(self, brand):
        self.car_brand = brand  #定义实例属性

    def move(self):  #方法
        # car_brand = 'Ferrari' 定义变量
        print('我的{}一脚油门飙到两百码'.format(self.car_brand))


    def toot(self):  #方法
        print('车在鸣笛')

 ferrari = Car_()
 banz = Car_('Banz')
 banz.move()  #调用方法

#访问属性
 print('我的奔驰颜色是{}'.format(banz.color))
#修改属性
 banz.color = 'red'
 print(banz.color)
#添加属性
 banz.wheelnum = 4
 print(banz.wheelnum)


#python的模块、包、库
#模块:.py文件
#包:包含__init__.py文件的文件夹
#库:具有相关功能模块的集合,
class ob:
    def o(self):
        print('过年前找到对象')

属性与方法相关概念

#属性与方法相关概念

#类属性和实例属性
#属于类的属性(类变量),在类中直接创建
#实例属性:属于实例对象本身,通过self.属性名创建
class Car_:  #定义类
    color = 'pink'  #定义类属性
    def __init__(self, brand):
        self.car_brand = brand  #定义实例属性

    def move(self):  #方法
        # car_brand = 'Ferrari' 定义变量
        print('我的{}一脚油门飙到两百码'.format(self.car_brand))


    def toot(self):  #方法
        print('车在鸣笛')

ferrari = Car_("Ferrar911")
 print(Car_.color)  #通过类名去访问类属性
 print(Car_.car_brand)  #通过类名无法去访问实例属性,实例属性属于实例对象本身  X
 print(ferrari.car_brand) #通过对象名去访问实例属性
 print(ferrari.color) #通过对象名去访问类属性


#私有属性和私有方法:
#私有属性是为了保护属性的安全性   ? tuple
#属性修改:直接修改与间接修改

class Person_:
    age = 18
    def person_info(self, name, age, gender):
        print('姓名:{}\n年龄:{}岁\n性别:{}\n'.format(name, age, gender))

 qingshan = Person_()
 print(qingshan.age)
 qingshan.age = 17  #直接修改
 print(qingshan.age)
 qingshan.person_info('青山', '18', '男') #间接修改
 qingshan.person_info('青山', '28', '男')
 print(qingshan.age)

#如果类中属性不想让外部修改,可以将属性定义为私有
#定义私有:在标识符前加入__


class Person_girlfriend:

    def __init__(self, age, weight):
        self.__age = age  #私有属性定义
        self.__girlfriend_weight = weight   #私有属性定义
        age_True = 28

    def __weight(self):  #定义私有方法
        print('体重:{}'.format(self.__girlfriend_weight))

    def girlfriend(self): #定义公有方法去访问私有属性和方法
        self.__weight()
        print(self.__age)  #访问私有属性



 xiaofang = Person_girlfriend(18, 79)
 print(xiaofang.__age) #私有属性无法访问
 xiaofang.__weight()  #私有方法无法调用
 xiaofang.girlfriend()  #定义公有方法去访问私有属性和方法



#魔法方法:__方法名__ 属于内置方法(一些特定的方法:进行特定操作且自动调用)

#__init__方法  每创建一个实例对象之后就将实例对象初始化,不是类的构造函数
class Car:  #定义类

    def __init__(self, brand,color):  #给实例对象进行初始化
        self.car_brand = brand  #
        self.color = color

 banz = Car_('Banz')


#__del__方法  在内存中销毁实例对象,会自动调用

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

    def person_info(self):
        print('姓名:{}\n年龄:{}岁\n性别:{}\n'.format(self.name, self.age, self.gender))

    def __del__(self):
        print('对象已销毁。。。。')

 qingshan = Person_del('青山', 18, '男')
 qingshan.person_info()
 qingshan

 import gc #真正释放内存
 a = 1
 del a
 gc.collect()


#__str__方法   返回对象的描述信息,需要print()函数进行输出,需要写入return
class Person_str:

    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '我是Person_str类的实例对象,我的名字叫{}'.format(self.name)

 qingshan = Person_str('青山')
 print(qingshan)


#__new__方法  类的构造函数,创建对象是会被自动调用,__init__的调用在__new__,一般情况不重写它
#必须要传递一个参数cls
#self:实例对象本身
#cls:类的本身

#创建对象的流程:
# 1、先调用__new__得到一个对象
# 2、再调用__init__方法给对象添加实例属性
# 3、将这个对象赋值给变量名

#单例设计模式:只有一个实例对象(一个全局使用的类频繁的创建与销毁)
#什么时候去用:控制实例数目,节省系统资源

class Person_new():
    count_1 = None
    def __new__(cls, *args, **kwargs):
        if cls.count_1 is None:
            cls.count_1 = super().__new__(cls)
        return cls.count_1

    def __init__(self):
        self.age = 18
 qingshan = Person_new()
 xiaofang = Person_new()
 print(id(qingshan))
 print(id(xiaofang))

# 面向对象:面向过程
# 封装:类,对象,属性,方法
# 继承:单继承,多继承

# 作业:创建一个汽车类:属性:轮胎个数,颜色,重量,油箱最大容量
#                     方法:加油,加速

#               创建法拉利的类:继承自汽车,对于方法需要重写:加油有最大油量,加速


class Auto(object):
# 上天,下水
    def __init__(self, color, weight, fuel_capacity=0, tire=4):
        self.color = color
        self.weight = weight
        self.fuel_capacity = fuel_capacity
        self.tire = tire

    def add_fule(self, value):
        self.fuel_capacity += value
        if self.fuel_capacity >=200:
            self.fuel_capacity = 200
            print('已经加满了')

    def add_speed(self, values):
        print(f'普通车辆百公里加速{values}秒')



class Ferrari(Auto):
#不建议重写__init__方法,可以通过实例对象再添加实例属性
    def __init__(self):
        super(Ferrari, self).__init__(color='pink', weight=200, fuel_capacity=50, tire=4)

    def add_fule(self, value):
        self.fuel_capacity += value
        if self.fuel_capacity < 120:
            print('emmm,没喝饱')
        elif self.fuel_capacity == 120:
            print('嗝~~!刚刚好')
        else:
            self.fuel_capacity = 120
            print('人家喝饱了Σ(っ °Д °;)っ')

    def add_speed(self):
        print('我加速百公里只需要5秒')

# LSP原则 面向对象的基本设计原则:继承只注重于步骤重写


 ferrari911 = Ferrari()
 s.add_fule(30)  #fule=50,80
 s.add_fule(40)  #120





# 多态
# 面向对象编程三大特性
# 封装:更具职责讲属性和方法封装到一个抽象类之中
# 继承:实现代码复用,不需要去重复编写且能够拓展
# 多态:不同的子类对象调用相同的父类方法,产生不同的执行结果(能够增加代码灵活度,多态依赖于继承)

# 多态的特点:只关心对象的实例方法是否同名,多态是调用技巧,不会影响类的内部设计

# 人 类,自己

class Person(object):

    def __init__(self, age):
        self.age = age

    def eat(self):
        print('是个人就得干饭')

    def sleep(self):
        print('是个人也得睡觉休息')


class Son:

    def eat(self):
        print('作为子女,老老实实按时吃饭')

    def sleep(self):
        print('老老实实早睡早起')


class Soul_Mate:

    def eat(self):
        print('和异性伴侣吃饭,比较浪漫')

    def sleep(self):
        print('美滋滋的去儒家')

class Friend:

    def eat(self):
        print('和朋友去干饭,得拿盆')

    def sleep(self):
        print('睡什么睡,起来嗨,我石头你亚索')


def sleep(obj):
    obj.sleep()

 role_1 = Son()
 sleep(role_1)
 role_2 = Soul_Mate()
 sleep(role_2)
 role_3 = Friend()
 sleep(role_3)

# 类也是个对象
# 类方法和静态方法

# 类方法:对类本身进行操作的方法,需要用到装饰器,类方法的第一个参数是cls
# 假设有个方法,这个方法再逻辑上采用类本身作为对象来调用更加合理
class Class_Method():
    def __init__(self):
        pass
    @classmethod
    def info(cls):
        print('正在调用类方法')

    def info_(self):
        pass

Class_Method.info()
s = Class_Method()
s.info()

# 静态方法(可以当成一个函数来理解):不需要访问实例属性和调用实例方法,也不用访问类属性和调用类方法(和__str__用处相似)
# 静态方法用来存放逻辑性代码,再逻辑上属于类,实际上和类本身没有关系
#
class Static_Method(object):
    @staticmethod
    def info():
        print('正在调用静态方法')

Static_Method.info()
s = Static_Method()
s.info()

# try-with open

def readFile(filename):
    try:
        with open(filename, 'r', encoding='utf8') as f:
            print(f.readlines())
    except:
        print('你有问题')
readFile('test.txt')


祝大家学习python顺利!!

 

原文:https://blog.csdn.net/weixin_54733110/article/details/118057219

声明:本文系转载文章,仅供学习交流使用,侵权请联系删除


2条回帖
z3193537  L0  评论于
(0)  回复(0) 1#
不错,学学
一叶花开  L10  评论于
(0)  回复(0) 2#
还没注册帐号?快来注册社区帐号,和我们一起嗨起来!
关于本社区

集各类兴趣爱好于一身的轻量化交流社区,在此您可以和他人一起分享交流您觉得有价值的内容,社区鼓励大家发表原创内容,为社区添砖加瓦!

创建版块 → 社区版规 → 招聘版主 →
推荐版块
扫描二维码下载社区APP
回到顶部