第二章 python基础知识梳理

love浩澜哥哥

已于 2022-10-02 14:55:14 修改

阅读量447

点赞数

分类专栏： Python Web开发从入门到实战文章标签：开发语言 python

于 2022-10-02 12:12:36 首次发布

本文链接：https://blog.csdn.net/weixin_50094325/article/details/127129024

版权

Python Web开发从入门到实战专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、变量和赋值

1. 变量命名：

变量命名可以包括字母、数字、下划线，但是不能用数字作为开头；

系统关键字不能作为变量名使用；

2. 格式化输入输出

如果希望输出文字信息的同时，一起输出数据，就需要使用到格式化操作符：

%s 字符串

%d 有符号十进制整数

%f 浮点数

3. 赋值语句

简单赋值、序列赋值、多目标赋值和增强赋值等。

序列赋值：

x1, y1 = 10, 20
(x2, y2) = 30, 40
[x3, y3] = 'ab'
((x4, y4), z4) = 'ab','cd'   #a, b, cd
x5, *y5 = 'abcd' #a, ['b', ' c', 'd']
*x6, y6 = [10, 20, 30, 'abc']   #[10, 20, 30], abc

二、分支和循环

程序结构分为3种：顺序结构、分支结构和循环结构。

分支结构：python使用 if 语句实现分支结构。最简单的三元表达式语法：表达式1 if 条件表达式 else 表达式2。即满足条件表达式执行表达式1，否则执行表达式2。

score = float(input('请输入一个成绩'))
if score < 60:
    print('差')
elif score < 70:
    print('中')
elif score < 80:
    print('良')
else:
    print('优')

循环结构：python使用 for 和 while 语句实现循环结构。循环中可使用 break、continue、和 pass来完成循环控制。

#使用 while 计算 1+2+...+100 的结果
result = 0
i = 1
while i <= 100:
    result += i
    i += 1
    print(f'结果为:{result}')
else:  #不管 while 条件是否满足，都会执行，可以省略
    print('执行完毕')

#循环输出 1...10 之间的所有偶数，如果数值等于 8 就跳过
for i in range(2, 11, 2):
    if i == 8:
        continue
        print(i, end = '\t')
else:
    print('循环执行完毕！')

三、数据结构

在 python 中，数据和字符串属于简单数据类型。集合、列表、元组、字典和范围均属于组合数据类型。组合数据类型的对象是一个数组容器，可以包含多个有序或无序的数据项。

1. 集合唯一、无序和不可改变得特点；用大括号表示{}，但是定义空集合得使用set()，否则{}为字典类型。

set1 = {1, 2, 3, 1, 3, 2}
print(len(set1))  #3
print('1' in set1)

set2 = {item for item in [1, 2, 3, 4]}
print(set1 - set2)     #求差集
print(set1 | set2)    #求并集
print(set1 & set2)    #求交集

2. 列表序列和可变特点；支持索引、分片和合并等操作；用中括号表示[]。

# 列表切片操作 
l1 = list(range(10))  #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[2:5])   #索引位置从 2 开始，取到索引位置为 4  [2, 3, 4]
print(l1[2:])    #索引位置从 2 开始，取到索引位置为最后一个  [2, 3, 4, 5, 6, 7, 8, 9]
print(l1[3:10:2]) #索引位置为 3 开始取到索引位置为 9，并步长为 2 [3, 5, 7, 9]
print(l1[10:3:-2]) #索引位置为 9 开始，取到索引位置为 4，逆向。步长且为 2 [9, 7, 5]

在列表切片时，当左或又索引值大于序列的长度值时，就用长度值作为该索引值。但注意不能索引超出范围的值，如上例若打印print(l1[10])，则会报错。

#列表常用方法
l2 = [1, 3, 3, 7, 5]
l2.append(5)
l2.remove(7)  #移除指定元素且排在第一位置的
l2.pop(0)  #按索引位置删除
l2.sort()  #升序排序
l2.reserve()  #反转

#列表解析(推导式)
print([x + 10 for x in range(10) if x % 2 == 0])  #[10, 12, 14, 16, 18]
print([x + y for x in(10, 20) if x > 10 for y in (1, 2, 3) if y % 2 ==1])   #[21, 23]

l1 = list(1) 是不可以的，print(l1) 会报错，因为 1 是不可迭代对象（不可循环遍历）；s1 = set('a') 进行print(s1) 得到 {'a'} 。

3. 元组序列和不可变特点；使用与字符串类似；用圆括号表示()。

包含一个对象的元组，不能缺少逗号，不然就是对象的类型，如 t1 = (2)，此 t1 为 int 型。

#创建元组
print((2,))
print(tuple('sdrf'))
print(tuple(item * 2 for item in range(5)))

#元组常用方法
t1 = (1, 2, 3, 4, 5)
print(len(t1))
print((2, 3) *3)   #(2, 3, 2, 3, 2, 3)
print(t1.count(1))  #统计指定值出现的次数，如果不包含指定值时，返回0
print(t1.index(2))  #查找指定范围内元素所在的索引    1

#索引和分片
t2 = tuple(range(10))
print(t2[1])
print(t2[-1])
print(t2[2:5])
print(t2[1:7:2])

4. 字典无序可变；包含一系列的键值对；用大括号表示{}。

dict1 = {'name': 'Jone', 'age': 25, 'sex': 'male'}
dict2 = {'book': {'Python编程': 100, 'C++入门': 99}}
dict3 = dict(name = 'Tom', age = 25)

#字典常用方法
dict1['name'] = 'tom'   # 修改映射值或新建映射   也可用 dict1.update(name = 'tom')
print(dict1['name'])   # 根据key获取value
print(dict1.get('name', 'default')) # 返回键 key映射的值, 如果键key不存在，返回默认值
print(dict1.pop('name', 'defaule')) # 从字典中删除键值对，并返回被删除的映射值。若键不存在，则返回default
print(dict1.items())  #返回键值对视图，视图对象支持迭代操作
print(dict1.keys())  # 返回字典中所有键的视图
print(dict1.values())  #返回字典中全部值的视图

四、函数

函数是完成特定任务的语句集合，调用函数会执行其包含的语句。函数的返回值通常是函数的计算结果，调用函数使用的参数不同，可获得不同的返回值。Python 利用函数实现代码复用。

1. 参数赋值传递：调用函数时会按照参数的先后顺序，依次将实参传递给形参。Python 允许以形参赋值的方式，将实参传递给指定形参。

2. 有默认值的可选参数：在定义函数时，可以为参数设置默认值。调用函数时，如果未提供实参，则形参取默认值使用。注意，带默认值的参数为可选参数，在定义函数时，应放在参数表的末尾。

3. 接受任意个数的参数：在定义函数时，可接受任意个数得参数，如果在参数名前面使用一个 * 号，表示形参是一个元组，如果是两个 ** 号，表示形参是一个字典。

def fn(num1, num2, other = -1, *args, **kwarges):
    print(num1, num2, other, args, kwarges)
fn(1, 2, 3, 4, 5, name = 'Tom', age = 18)   #1 2 3 (4, 5) {'name':'Tom', 'age': 18}

lambda 函数（匿名函数）

将 lambda 函数赋值给变量，通过变量调用函数。lambda 表达式基于数学中的 λ 演算得名，它主要得作用就是简化函数代码，与 def 不同， lambda 只能用一行表示。lambda 函数定义得基本语法为：lambda 参数表：表达式

def fn1(): return 100
lambdaFn1 = lambda: 100

def fn2(x, y): return x + y
lambdaFn2 = lambda x, y : x + y

五、面向对象（封装继承）

类的属性：类属性和实例属性

类属性只要在类定义内，类方法定义外即可，它是一个类的全局变量，是所有对象共享的一个变量
实例属性定义在 _init_ 中，每个对象之间相互独立。如果在实例属性名前加上 _ 就变成一个私有变量，在类的外部是不可见的，内部可以使用 self 访问

类的方法：实例方法、类方法和静态方法

实例方法定义时，需要将实例对象本身作为隐含的第一个参数传递给方法，所以在定义时，通常第一个参数名称为 self ，使用 self 只是惯例，重要的是位置，完全可以用其他的名称来代替 self
静态方法定义时，需要在前一行加上一个装饰器 @staticmethod ，调用的时候直接用类名访问，不需要将实例对象本身作为隐含的第一个参数传递给方法
类方法与静态方法类似，也需要一个装饰器 @classmethod ，依然是用类名调用它，唯一不同的是类方法多了一个 cls 参数，它是类名，系自动注入

#类定义语法格式
class ClassName:
    class_property = 0  # 没有使用self，并且写在方法外，这是类属性，它是共享的

    def _init_(self, prop_val):   # 初始化方法，即构造方法
        temporary_val = -1  # 写在方法里，但是没有self，这是一个局部变量
        self.instance_property = prop_val   # 有self，这里创建了一个实例属性，只需要赋值就可以创建
        ClassName.class_property += 1  # 操作类属性需要写类名

    def instance_method(self, prop_val):
        """
        实例方法，与前面的学习过的函数几乎一样，区别在于第一个参数必须是 self，隐式传入，实例自己
        :param prop_val:
        :return:
        """
        print(prop_val)
        pass

    @staticmethod 
    def static_methoc():
        pass

    @classmethod
    def class_method(cls):
        pass

# 对象实例化和类成员信息调用示例
obj_instance = ClassName('prop_val')  # 创建对象的语法
obj_instance.instance_property = 0  # 调用属性，并赋值为0
print(ClassName.class_property)   # 类对象直接读取类属性
print(obj_instance.class_property)  # 实例对象读取类属性

ClassName.static_mathod()  # 调用静态方法
ClassName.class_method()   # 调用类方法
obj_instance.instance_method('inst_val')   # 调用实例方法

# 类定义和实例化操作
class Person:
    name = 'Person Class'

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

    @staticmethod
    def show():
        return Person.name

    def show_info(self):
        print(f'name:{self.name}, age:{self.age}, sex:{self.sex}')

obj = Person("Tom", 18, 'male')
obj.show_info()
print(Person.show())

类继承

通过继承，新类可以获取现有类的属性和方法，新类称作子类或派生类，被继承的类称作父类、基类或超类。在子类中可以定义新的属性和方法，从而完成对父类的扩展。

class Person:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def show_info(self):
        print(f'name:{self.name}, age:{self.age}, sex:{self.sex}')

class Student(Person):   # 这里加了一个括号表明父类是 Person
    def __init__(self, name, age, sex, stu_id):
        super().__init__(name, age, sex)  # super 就是父类，调用父类的 初始化方法初始化参数
        self.stu_id = stu_id # 子类特性

    def show_info(self):   # 重写父类方法
        print(f'name:{self.name}, age:{self.age}, sex:{self.sex}, stu_id:{self.stu_id}')

stu = Student("Tom", 18, 'male', 2022001)
stu.show_info()

六、模块和包

模块是一个包含变量、函数或类的程序文件，若文件中包含一个名为 __init__.py 的文件，则是一个包。Python 也提供了大量的内置模块，并可集成各种扩展模块。

1. 采用 import 模块名的方式，导入模块中的所有函数，调用的时候需要通过模块名.函数的形式调用。也可以在模块名后面使用 as 关键字给模块重命名，这种方式主要用来避免模块之间函数名冲突。

2. 采用 from 模块名 import 函数名的方式，导入模块中指定的函数，调用的时候，函数名前不需要加上模块名。也可以把函数名换成 * 号，导入所有函数。

# pythontest.py

from templates.pack1.Demo1 import Person, show, name
print(name)
show()
Person.show()
obj = Person('Jim', 21)
obj.show_info()

# Demo1.py
name = 'Demo Package Model'
def show():
    print('hello world')

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

    def show_info(self):
        print(f'name:{self.name}, age:{self.age}')

    @staticmethod
    def show():
        print('This is Person StaticMethod')

这节课学完啦，一向不用 pycharm 的我这次懂得了许多操作，但还现在只是跟着老师做，要自己熟练运用还有待加强哦！

记录下怎么在 pycharm 中安装包：点击 terminal ，然后pip install 名称即可