【python】基础知识复习

已于 2023-01-27 14:59:59 修改
阅读量239 收藏
点赞数
文章标签： python 开发语言
于 2023-01-27 14:57:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youngberry_/article/details/128770766
版权
文本和字符集的概念

纯文本在计算机底层会以二进制进行存储，涉及三个动作：

1.编码：文本转化为二进制

2.解码：二进制转化为文本

3.文本集：编码解码的规则（ASCII(美国), GBK(国标), Unicode(万国), ISO-8859-1(欧洲)）

Unicode:UTF-8 & UTF-16 & UTF-32，最常用的是UTF-8

UTF-8：使用1-5个字节

UTF-16: 使用2-4个字节

UTF-32: 固定4个字节

编译型和解释性（吃菜和吃火锅）

1.编译型：全部编译完后再一把执行

动作：源码 -> 编译 -> 执行编译后的机器码

特点：1.速度快 2.跨平台差

2.解释型：解释一句执行一句

动作：源码 -> 解释 -> 解释执行

特点：1.速度慢 2.跨平台好

数值

python中所有的浮点型都是float，直接运算的话，结果只是近似精确

字符串

python中的三引号可以保留字符串中原始格式，可以换行

a = '''i
am
word
'''
字符串格式化
print("hello %s" %"world") #hello world
print("hello %3s" %"world") #hello wor
print("hello %3.5s" %"world") #限制字符串再3~5个字符串之间
print("hello %.2f" %1.2344555) #hello 1.23
字符串与整数相乘
print('abc' * 2)
#abcabc
检查类型
#type
a = 123
print(type(a)) #int
对象的概念

python是一门面向对象的编程语言

对象是什么

就是再计算机内存中开辟的一小块专门存储的区域，里面有我们需要存储的数据

对象的结构

id（内存地址）只要对象创建，这个id就不会再变

value (可变对象 & 不可变对象)

type 只要对象创建，这个type就不会再变

变量和对象的关系

变量是对象的别名，变量中存储的是对象的地址

is和is not

比较是不是同一个对象

a = [1,2,3]

b = [1,2,3]

print(a == b) #True

print(a is b) #False

Set

1.只能存储不可变对象

2.存储顺序与插入顺序无关

3.存储的元素唯一

4.集合可以进行逻辑计算，返回个新集合 & ,|,-,^,<=(检查是否是子集),<

a = set() #创建空集合，也可以把任何序列变成集合
a = {}
a.update({'1' ,'2', '3'}) #集合可以用update插入序列中的元素，和字典一样
a.update({'a':1, 'c':2, 'd':3}) #集合update字典只会插入字典的键

函数

不定量参数（装包）
#不定长的参数必须卸载所有参数的最后一个，否者在它后面的参数只能用关键字参数赋值
def sum(*a): #输入的所有参数（位置参数），都会装包进一个元组中
	for i in a:
		print(f"{sum += i}"")
num1,num2,num3 = 1,2,3
sum(num1,num2,num3) #6
              
def fn2(*a, b=3): #星号参数放在前面时，后面的参数（位置参数）只能用默认值给参
    print('a = ', a ,type(a))
    print(b)
num1,num2,num3 = 1,2,3
fn2(num1,num2,num3)
              
def fn3(**a): #双星号的形参会将接受的参数（关键字参数）统一保存在字典，字典的key就是参数的名字，字典的value就是参数的值
	print('a = ', a ,type(a))
num1,num2,num3 = 1,2,3
fn3(num1, num2 num3)
不定长参数拆包
#解包
def fn3(a,b,c): #可以用*号给函数入参，会自动拆解序列，给形参复制，但是序列元素必须和形参个数一致
	print(a+b+c)
nums = [1,2,3]
fn3(*nums) #6
nums_dict = {'a':1,'b':2,'c':3} #字典可以通过**解包,注意这里字典的键要和形参一样
fn3(**nums_dict)
文档字符串
def fn3(a:int,b:int,c:int): #可以用*号给函数入参，会自动拆解序列，给形参复制，但是序列元素必须和形参个数一致
    '''此函数用来打印三个数的和'''
	print(a+b+c)
help(fn3) #用来打印函数开头的注释，和参数类型解释
命名空间

命名空间时存储变量的一个空间，其实是个字典

#在当前位置调用locals()可以看到当前区域命名空间的变量
a = 1
b = 1
scope = locals()
print(scope)

#打印函数命名空间的变量
def test():
    a = 2
    scope1 = locals()
    scope2 = globals() #获取全局命名空间
    print(scope2)
    print(scope2)
高阶函数

第一种高阶函数可以接受函数作为参数

#定义这样一个函数，传入函数规则，则按照规定规则给list排序
def odd(num):
    if num%2 != 0:
        return True
    else:
        return False
def even(num):
    if num%2 == 0:
        return True
    else:
        return False    
def func(rule,nums):
    new_list = []
    for i in nums:
        if rule(i):
            new_list.append(i)
    return new_list
print(func(odd,[1,2,3,4,5,6])) #注意这里函数作为参数时，不需要给括号
匿名函数lambda
print((lambda a,b:a+b)(1,2)) #匿名函数的声明和调用，一般也不这么用
def func(rule,nums): #一般会这样用，定义一些轻量化的函数
    new_list = []
    for i in nums:
        if rule(i):
            new_list.append(i)
    return new_list
print(func(lambda i:i%2==0, [1,2,3,4,5,6])) #注意这里函数作为参数时，不需要给括号

#搭配filter()使用，filter可以按照你的规则，筛选可迭代序列，并返回一个新序列对象
new_list1 = filter(lambda i:i%2==0, [1,2,3,4,5,6])
print(f"new_list1:{list(new_list1)}") #filter返回的对象需要list一下才能成为列表

#搭配map()使用，map可以按照你的规则，对可迭代序列的每个对象进行操作，并返回一个新的序列对象
new_list2 = map(lambda i:i*i, [1,2,3,4,5,6])
print(f"new_list2:{list(new_list2)}") #map返回的对象需要list一下才能成为列表

#搭配sorted()使用，sorted可以按照你的规则，对可迭代序列进行排序，并返回一个新序列
new_list3 = sorted(['a','aaaaaa','aa'], key=len)
print(new_list3)
class_dict = [{'name':'joker', 'age':18}, {'name':'july', 'age':10}, {'name':'peter', 'age':22}] 
new_class_dict = sorted(class_dict,key = lambda i : i['age'])
print(new_class_dict)

第二种高阶函数将函数作为返回值

闭包
#求平均值方式：不好的地方是nums是个全局变量，允许被其他地方修改，变量安全性不高
nums1 = []
def averager(n):
	nums1.append(n)
	print(sum(nums1)/len(nums1))

#闭包方式:nums是make_averager私有变量，只能被内部闭包函数调用，安全高
def make_averager():
    nums2 = []
    def averager(n):
        nums2.append(n) #必须使用到外层函数的定义的变量
        print(sum(nums2)/len(nums2))
    return averager #闭包函数必须以内部函数作为返回值
func = make_averager() #初始化闭包函数
func(1) #调用闭包函数
func(2) #调用闭包函数
装饰器
#装饰器可以在不改变原函数的同时，对函数进行拓展，满足OCP原则（程序涉及要求开发对程序的拓展，关闭对程序的修改）
#装饰器第一种用法
def add(a,b):
	print(a+b)
def echo():
    print('I LOVE YOU')
def begin_end(old):
    def new_func(*arg,**kargs):
        print("函数开始")
        old(*arg,**kargs)
        print("函数结束")
    return new_func
fun1 = begin_end(add)
fun2 = begin_end(echo)
fun1(1,2)
fun2()

#装饰器第二种用法
@begin_end#在这后面定义函数
def say_hello():
    print('Hello World')
say_hello()

面向对象

class MyClass: #创建类
	pass
a = MyClass() #类的实例化
print(isinstance(a,MyClass)) #判断是否的某个类的实例
a.name = 'xy' #定义类的属性
print(a.name)#类属性的调用

#再复杂一点的类
class Person:
    name = 'swk' #类的公共属性，所有实例都可以访问
    def say_hello(self): #类中定义的函数（方法），必须要定义一个形参，调用时传进去的第一个参数就是实例对象本身
        print('hello')
a = Person
a.say_hello() #方法的调用时，第一个参数时由解析器自动传递

创建类和类的实例化的过程

在这里插入图片描述

类的实例中，如果没有自己的属性值，会往上找其type的属性值，如果有则用自己的属性值

class Person:
    name = 'swk'
 	def hello(self):
        print(f"Hello {self.name}")
a = Person()
b = Person()
b.name = 'zbj'
print(a.name) #swk
print(b.name) #zbj
b.hello()
del b.name #删除b的属性
print(b.name) #swk

在这里插入图片描述

我们希望在创建类的实例时，同时给类的属性赋值，如不赋值，类的实例无法被创建

#类的基本结构
class Person:
    #在类中定义一些特殊方法
    #特殊方法在实例化时，解析器会自动调用
    #搞清楚1.特殊方法什么时候调用 2.特殊方法有什么用
	__init__(self,name):
        self.name = name #这样给name赋值与上面赋值方式的区别在于，这种的name存在与实例对象中，上面一种存在于类对象中,并且初始化必须要给'name'实参才能初始化，达到目的
   	def hello(self):
        print(f"Hello,{self.name}")
a = Person('zbj')
a.hello()

增强属性的安全性

1.属性不能随意被修改

2.属性的类型或值进行规定

#封装，1.将不希望被外界访问到的属性隐藏起来
class Person:
    def __init__(self, name):
        self.hidden_name = name #hidden_name不会被外界所访问到
    def hello(self):
        print(f"Hellp {self.hidden_name}")
    def get_name(self): #2.可以定义getter和setter函数去获取和设置被封装起来的属性，如果只希望属性是只读的那么就去掉setter方法
        return self.hidden_name
    def set_name(self,name): #3.设置set方法可以给设置数据时，可以数据是否可设置
        self.hidden_name = name

#更绝的隐藏方式，采取"__"双下划线为开头的类的属性，只能在类的内部使用，无法被外界访问
class Person:
    def __init__(self, name):
        self.__name = name #hidden_name不会被外界所访问到,本质上解释器改成了“_Person__name”
    def hello(self):
        print(f"Hellp {self.__name}")
    def get_name(self): #2.可以定义getter和setter函数去获取和设置被封装起来的属性，如果只希望属性是只读的那么就去掉setter方法
        return self.__name
    def set_name(self,name): #3.设置set方法可以给设置数据时，可以数据是否可设置
        self.__name = name

优化上面的封装方式，因为上面这种封装方式需要用户调用get方法和set方法，为了减少工作量，可以用@property()和@var.setter装饰器，讲封装的变量作为属性去访问

class Person:
    def __init__(self, name):
        self.__name = name
	@property
    #方法名‘name’需要和隐藏属性同名
    def name(self):
        return self.__name
   	@name.setter #装饰器.前面的名字需要和隐藏属性同名,有set必须要有get
    #方法名‘name’需要和隐藏属性同名
    def name(self, name):
        self,__name = name
a = Person('swk')
print(a.name)
a.name = 'zbj'
print(a.name)
继承
class Animal(object): #object类时最底层的基类
	def __init__(self, name):
		self.__name = name
	@property
	def name(self):
		return self.__name
	@name.setter
	def name(self, name):
		self.__name = name
	def run(self):
		print(f"{self.__name} run")
class Dog(Animal):
    def __init__(self, name, age):
	    super().__init__(name) #用super（）去继承父类的所有属性和方法
	    self.age = age
    def gou_jiao(self):
        print(f"{self.name} {self.age} wangwangwang")
dog = Dog('gou A', 10)
dog.run()
dog.gou_jiao()

多态

class Dog():
	def __init__(self, name, age):
		self.__name = name
		self.__age = name
class Cat()
	def __init__(self, name, type):
		self.__name = name
		self.__type = type
class Person()
	def __init__(self, age):
		self.__age = age
def say_hello(obj):
	print("Hello %s" %obj.name)
a = Dog('xiaowang', 10)
b = Cat('xiaohua', 'mao')
c = Person(18)
say_hello(a) #有name属性的对象都可以作为函数入参
say_hello(b)	#有name属性的对象都可以作为函数入参#类的多态
class Dog():
	def __init__(self, name, age):
		self.__name = name
		self.__age = name
	@property
	def name(self):
		return self.__name
class Cat():
	def __init__(self, name, type):
		self.__name = name
		self.__type = type
	@property
	def name(self):
		return self.__name
class Person():
	def __init__(self, age):
		self.__age = age
def say_hello(obj):
	print("Hello %s" %obj.name)
a = Dog('xiaowang', 10)
b = Cat('xiaohua', 'mao')
c = Person(18)
say_hello(a) #有name属性的对象都可以作为函数入参,但要注意，如果属性有封装，该属性必须可访问
say_hello(b)	#有name属性的对象都可以作为函数入参，如果属性有封装，该属性必须可访问
say_hello(c) #没有name属性的对象不可以作为函数入参

​

垃圾回收：将无用的对象从内存中删除

当没有任何的变量对对象引用时，就会被垃圾回收

模块

#定义私有的变量
_c = 30 #在模块中变量前加上_，在import模块时，不会引入该变量

包

包含很多模块的文件夹

包中必须包含__init__.py这个文件

引用包也用import

标准库

import pprint
import sys
import os
dict = {'1':'haha', '2':'xixi', '3':'wowow', '4':'kakaka'}
pprint.pprint(dict) #漂亮打印，自动换行
print(sys.path) #找模块的路径
print(os.environ) #打印环境变量

抛异常

class MyError(Exception): #自定义异常关键字
    pass
def add(a, b):
	if a < 0 or b < 0:
    	raise MyError('不能为负数')#主动抛异常
    else:
		return a+b
大 洋
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【python】考前复习，python基础语法知识点整理
云泽野の编程日记
02-23 2846
文章目录:1.常量与表达式2.变量和数据类型 创建变量 数据类型 动态类型 数据类型的转换 3.注释 4.字符串 字符串的定义方式 字符串的拼接 字符串的格式化① 字符串格式化的精度控制 字符串的格式化② 对表达式进行格式化 5.从控制台输入(input) 6.运算符 算术运算符 赋值运算符 布尔类型和比较运算符 7.条件语句 if语句 if else语句 if elif else语句 判断语句的嵌套 8.循环 while循环 循环语句的嵌套 for循环 range语句 continue和break
Python基础知识总结（期末复习精简版）
一条小黑龙的博客
05-28 6万+
华中农业大学Python期末考试速成笔记
python快速复习-基础篇
qq_45452617的博客
09-30 2129
黑马程序员的笔记，互相学习，只是为了自己快速浏览所用
Python期末复习知识点汇总一（课本）
qq_58221901的博客
04-13 2104
第一章 “>＞>”是Python语言运行环境的提示符，其表示可以在此符号后面输入Python语句 在提示符后输入exit（）或者quit（）可退出Python运行环境。 Python的语言特点（解释型）：​​​​​​​ 语法简洁 与平台无关 粘性扩展（具有优异的扩展性） 通用灵活 强制可读（通过强制缩进来体现语句间的逻辑关系） 支持中文（采用utf-8编码表达所有字符信息） 模式多样 类库丰富 每个程序都有一套统一的运算模式：输入数据，处理数据，和输出数据。（IPO）（Inp
全套Python复习资料：重点总结+题库，助你一天复习完Python，高分通过Python！
libaiup的博客
06-13 401
但是Python，毕竟作为一门有一定难度的科目，，来帮你战胜Python，考出高分！特别是对于非计算机专业的同学，大家现在的困惑无非下面几点！【保证100%免费】
Python基础知识复习笔记
09-29
自己整理的python基础笔记，不当之处欢迎指正！
Python基础知识复习.pdf
07-23
Python基础知识复习.pdf
Python基础知识复习.pdf.pdf
10-02
Python基础知识复习 Python基础知识复习.pdf.pdf是Python基础知识的总结，涵盖了Python基础知识的多个方面，包括切片操作、注释方式、zip函数、不同进制数的表示、append函数、列表的乘法、元组的特性、字典的键、...
Python基础知识复习.docx
10-11
Python基础知识复习.docx
Python入门基础知识总结（赶紧收藏）
热门推荐
Python84310366的博客
07-13 7万+
Python入门基础知识总结（赶紧收藏）
最全Python基础知识点梳理
xiangxueerfei的博客
10-28 1136
本文主要介绍一些平时经常会用到的python基础知识点，用于加深印象，也算是对于学习这门语言的一个总结与回顾。python的详细语法介绍可以查看官方编程手册，也有一些在线网站可以学习
Python期末复习资料
Smartloe的博客
01-01 1365
Python期末复习资料
一份超全的Python学习资料汇总。。
xiangxueerfei的博客
02-15 923
如果你是个技术小白，安装 Python 环境可不是你的首要任务。如果你有一份全职工作，或者你是一名学生，完成这些流程可能需要更长的时间。所以，你必须把你的知识应用到一个项目中。你不需要掌握所有的知识，但是你应该知道一些常识，因为它们会影响你的日常工作。这里把Python常用的技术点做了整理，有各个领域的知识点汇总，可以按照上面的知识点找对应的学习资源。光学理论是没用的，学习编程切忌纸上谈兵，一定要动手实操，将自己学到的知识运用到实际当中。如果你非常「疯狂」，并且非常专注，你可以在一个月内完成这些任务。
python期末复习——python知识要点
yuanyuan320的博客
11-25 4933
a,1= 进程的三种基本状态及其转换？ 基本状态： 就绪状态。执行状态。阻塞状态。 转换： 就绪到执行： 进程调度程序按一种选定的策略从中选中一个就绪进程，为之分配了处理机后，该进程便由就绪状态变为执行状态 执行到阻塞： 正在执行的进程因发生某等待事件而无法执行，则进程由执行状态变为阻塞状态 阻塞到就绪： 处于阻塞状态的进程，在其等待的事件已经完成，并不马上转入执行状态，而是先转入就绪状态，然后再由系统进程调度程序在适当的时候将该进程转为执行状态 执行到就绪： 正在执行的进程，因时间片用完而被暂停执行，或在
python期末复习知识点总结
weixin_40184069的博客
07-03 1万+
期末复习知识点总结 第一章 1.6 Python编程规范与代码优化建议 1.7 模块 模块的导入方式 补：Python编程规范与代码优化建议 注释 以符号#开始，表示本行#之后的内容为注释。 #eg1_2.py coding=gbk n = int(input("请输入一个整数：")) k=1;sum=0 for i in range(1,n+1): sum=sum+k print("sum=",sum) 缩进 类定义、函数定义、选择结构、循环结构、with快，行尾的冒号表示缩进的开
python复习笔记
m0_51928077的博客
11-25 505
浮点数 字符串 布尔类型 … 2.算术运算符 有：+ - * / % ** //求乘方 // 取整除法（地板除），整数除以整数，还是整数，但舍弃了小数部分，向下取整 3.关系运算符 有: < >= == !=像and or not 这一系列的运算符称为 逻辑运算符= 赋值 两数互换： 6.复合赋值运算符 复合赋值运算符. 例如 *+= -= = /= %= 二.函数 1.语法格式 2.使用函数 例： 求 n~m 之间的和 3.返回多个值 除了可以返回单个值之外，还可以返回多
python基础知识点汇总（最全最详细)
weixin_73956443的博客
03-10 1377
【python】基础知识点汇总（最全最详细）
python期末复习笔记
qq_60335571的博客
06-13 3916
大一大二python期末复习用，配套教材《python语言程序设计基础》
python大一知识点,Python复习知识点（一）
weixin_35804557的博客
03-26 4522
. python简介Python是一种解释型语言Python使用缩进对齐组织代码执行，所以没有缩进的代码，都会在载入时自动执行数据类型：整形 int 无限大浮点型 float 小数复数 complex 由实数和虚数组成Python中有6个标准的数据类型：Number(数字)String(字...
python基础大学期末复习
最新发布
06-13
Python基础大学期末复习通常会覆盖以下几个关键点： 1. **字符串处理**[^1]： - 字符串是Python中的基本数据类型，可以通过索引(indexing)访问单个字符，如`s[index]`。 - 切片(slicing)用于选取子字符串，如`s[start:end]`。 2. **序列操作**： - 除了字符串，Python中的列表也是序列类型，同样支持索引和切片。 - 列表方法包括但不限于：`append()`添加元素，`pop()`删除并返回最后一个元素，`sort()`对列表排序等。 3. **列表相关方法**： - Python提供了丰富的列表操作函数，如`len()`计算长度，`extend()`连接两个列表，`reverse()`反转列表等。 4. **函数和模块**：理解如何定义和调用函数，以及如何导入和使用内置或自定义模块。 5. **控制流结构**：if语句，for循环，while循环等，以及异常处理。 6. **数据结构**：深入理解元组(tuples)、集合(set)和字典(dictionary)的特性和用法。 7. **面向对象编程**[^3]：Python是面向对象的，了解类(class)、对象(object)、属性(attribute)和方法(method)的概念。 复习时，建议通过做练习题和模拟考试来巩固这些知识点。同时，熟悉常见错误和调试技巧也是重要的部分。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值