Python基础知识学习：从零到100

这篇博客将介绍Python基础知识，包括：

Python变量的工作原理
Python条件语句的工作原理
Python循环（while&for）的工作原理
如何使用列表：集合|数组
字典键值集合
迭代数据结构
对象和类
数据作为对象的属性
方法作为对象的行为
使用Python getters和setters & 属性装饰器
封装：隐藏信息
继承：行为和特征

首先：什么是Python？

Python属于高级解释型语言的范畴。高级语言是机器无法直接理解的语言。它的语法有一定程度的抽象。机器通常设计为读取 machine code机器代码，但高级语法不能直接转换为机器代码。因此，必须先将其 bytecode转换为字节码，然后将其转换为机器码，然后才能执行程序。

Python 是一种解释型语言，因为在执行过程中，每一行都会随时随地解释为机器语言。
“Python是一个：高级编程语言，其核心设计理念是代码的可读性和语法，使程序员能够用几行代码表达概念。” 学习Python的第一个原因是，它是一种漂亮的编程语言，编码并表达想法很自然。另一个原因是Python在数据科学、网络开发和机器学习都大放异彩。 Quora、Pinterest和Spotify都使用Python进行后端web开发。

基础知识

1. 变量

2. 控制流：条件语句

3. 循环/迭代器

4. 列表：集合|数组|数据结构

List 是一个集合，可用于存储值列表（如所需的这些整数）。List 有一个概念叫做索引。第一个元素获取索引 0（零）。第二个得到 1

5. 字典：键值数据结构

Dictionary 是键值对的集合。键是指向值的索引 value。

6. 迭代：遍历数据结构

7. 类和对象

Objects对象是现实世界对象（如汽车、狗或自行车）的表示形式。这些对象共享两个主要特征：数据和行为。

汽车有数据，如车轮数量、门数和座位容量它们还表现出行为：它们可以加速、停止、显示还剩多少燃料，以及许多其他事情。将数据定义为属性attributes ，将行为识别为对象编程中的属性方法。 再：

数据→属性和行为→方法

类是从中创建单个对象的蓝图。在现实世界中经常会发现许多相同类型的物体。比如汽车，所有相同的品牌和型号（并且都有发动机、车轮、门等）。每辆车都是根据同一组蓝图建造的，并具有相同的组件。

8. Python 面向对象编程模式：开启

Python作为一种面向对象的编程语言，具有以下概念：类和对象。类是蓝图，是其对象的模型。

类只是一个模型，或者一种定义属性和行为的方法。例如，车辆类具有自己的属性，用于定义哪些对象是车辆。车轮数量、油箱类型、座位容量和最大速度都是车辆的属性。

对象是类的实例。通过命名类来创建一个实例。

car是Vehicle类的对象（或实例）。车辆类别有四个属性：车轮数量、油箱类型、载客量和最大速度。在创建车辆对象时设置所有这些属性。

init() 称之为构造函数方法
eg：当创建车辆对象时，可以定义这些属性。想象一下喜欢特斯拉Model S，它有四个轮子，依靠电能运行，有五个座位的空间，最大速度为250公里/小时（155英里/小时）。

如何访问这些属性的值呢？向对象发送一条消息，询问他们的情况，称之为方法。这是物体的行为。
number_of_fheels和set_number_of_feels 称之为getter和setter。因为第一个获取属性值，第二个为属性设置新值。
在Python中可以使用@property（decorators）来定义getter和setter。

也可以使用其他方法，比如“make_noise”方法

9. 封装：隐藏信息（Encapsulation: Hiding Information）

封装是一种限制直接访问对象的数据和方法的机制。但同时，它方便了对该数据（对象的方法）的操作。

“封装可以用来隐藏数据成员和成员函数。在这个定义下，封装意味着对象的内部表示通常隐藏在对象定义之外。

对象的所有内部表示都对外部隐藏。只有对象可以与其内部数据交互。
首先需要了解公共和非公共实例变量和方法是如何工作的。

10. 公共实例变量 & 非公共实例变量

对于Python类可以在构造函数方法中初始化一个公共实例变量。可以使用公共实例变量和类属性，公共部分的另一个有趣之处在于可以管理变量值：Get和Set变量值。

非公共实例变量：不使用术语“private”，因为在Python中没有任何属性是真正私有的（没有通常不必要的工作量）

作为公共实例变量，可以在构造函数方法或类中定义非公共实例变量。语法上的区别是：对于非公共实例变量，在变量名之前使用下划线（_）。

“Python中不存在只能从对象内部访问的“Private”实例变量。但是通常来说大多数Pythone代码都遵循的：前缀为下划线（例如_spam）的名称应视为API的非公共部分（无论是函数、方法还是数据成员）

非公共变量只是一种约定，应该被视为API的非公共部分。

11. 公共方法 & 非公共方法

可以在类外使用公共方法，但无法使用非公共方法。

非公共方法只是一种约定，应该被视为API的非公共部分。

有一个_get_age非公共方法和一个show_age公共方法。show_age可以由对象使用（在类之外），而_get_age只能在类定义内部使用（在show_age方法内部）。

12. 封装

通过封装，可以确保对象的内部表示对外部隐藏。

13. 继承：行为和特征（Inheritance: behaviors and characteristics）

某些对象有一些共同点：它们的行为和特征。例如，从父亲那里继承了一些特征和行为。我继承了他的眼睛和头发作为特征，继承了他的急躁和内向作为行为。

在面向对象编程中，类可以从另一个类继承公共特性（数据）和行为（方法）。想象一下一辆汽车：车轮数量、座位容量和最大速度都是汽车的特性。可以说ElectricCar类从常规Car类继承了这些相同的属性。

一旦初始化就可以使用创建的所有实例变量。在Python中，将父类作为参数应用于子类。ElectricCar类可以从Car类继承。不需要实现任何其他方法，因为这个类已经有了它（继承自Car类）。

源码

# basic_python.py 

# 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：
# -*- coding: utf-8 -*-

print('hello world')

print(1, True, False, "good", 3.25)

# 多个print打印在一行里
print('你好 ', end="")
print('世界', )

print('你好 ', end=" ")
print('世界', )

x = "a"
y = "b"
# 换行输出
print(x)
print(y)

print('---------')
# 不换行输出
print(x, end=" ")
print(y, end=" ")
print()

a, b, c = 1, 2, "runoob"
print(a, b, c)

# 单行注释
# 多行注释可以用档字符串，它们被包裹在三引号中， """
"""多行注释
多行注释
多行注释"""

# python保留字
import keyword

print(keyword.kwlist)

if True:
    print("True")
else:
    print("False")

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
print(word, sentence, paragraph)

# Python3 中常见的数据类型有：Number（数字）、String（字符串）、bool（布尔类型）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）
# Python3 的六个标准数据类型中：不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
# list
list = ['abcd', 786, 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']

print(list)  # 输出完整列表
print(list[0])  # 输出列表第一个元素
print(list[1:3])  # 从第二个开始输出到第三个元素
print(list[2:])  # 输出从第三个元素开始的所有元素
print(tinylist * 2)  # 输出两次列表
print(list + tinylist)  # 连接列表

# tuple
tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')

print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组的第一个元素
print(tuple[1:3])  # 输出从第二个元素开始到第三个元素
print(tuple[2:])  # 输出从第三个元素开始的所有元素
print(tinytuple * 2)  # 输出两次元组
print(tuple + tinytuple)  # 连接元组

# set
sites = {
    
    'Google', 'Taobao', 'Google', 'google', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)  # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites:
    print('Runoob 在集合中')
else:
    print('Runoob 不在集合中')

age = 5
if age <= 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age - 2) * 5
    print("对应人类年龄: ", human)

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)  # a 和 b 的差集
print(a | b)  # a 和 b 的并集
print(a & b)  # a 和 b 的交集
print(a ^ b)  # a 和 b 中不同时存在的元素

# dict
dic1 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
dic2 = {
    
    x: x ** 2 for x in (2, 4, 6)}
dic3 = dict(Runoob=1, Google=2, Taobao=3)
dict = {
    
    }
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"

tinydict = {
    
    'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}

print(dict['one'])  # 输出键为 'one' 的值
print(dict[2])  # 输出键为 2 的值
print(dict, dic1, dic2, dic3)
print(tinydict)  # 输出完整的字典
print(tinydict.keys())  # 输出所有键
print(tinydict.values())  # 输出所有值

# 循环
for i in range(0, 10): print(i, end="")

n = 100

sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n, sum))

count = 0
while count < 5:
    print(count, " 小于 5")
    count = count + 1
else:
    print(count, " 大于或等于 5")

# else for循环结束后执行
for x in range(6):
    print(x)
else:
    print("Finally finished!")

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

# Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句
for letter in 'Runoob':
    if letter == 'o':
        pass
        print('执行 pass 块')
    print('当前字母 :', letter)

print("Good bye!")

# Python 推导式：一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
# 列表(list)推导式、字典(dict)推导式、集合(set)推导式、元组(tuple)推导式
names = ['Bob', 'Tom', 'alice', 'Jerry', 'Wendy', 'Smith']
new_names = [name.upper() for name in names if len(name) > 3]
print(new_names)

listdemo = ['Google', 'Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {
    
    key: len(key) for key in listdemo}
print(newdict)

dic = {
    
    x: x ** 2 for x in (2, 4, 6)}
print(dic)

setnew = {
    
    i ** 2 for i in (1, 2, 3)}
print(setnew)

a = (x for x in range(1, 10))
print(a)

list1 = ['python', 'test1', 'test2']
list2 = [word.title() if word.startswith('p') else word.upper() for word in list1]
print(list2)

# 迭代器
list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
for x in it:
    print(x, end=" ")

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
while True:
    try:
        print(next(it))
    except StopIteration as e:
        print(e)
        if (e.value == None):
            break


# 生成器
# 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
# 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
# 调用一个生成器函数，返回的是一个迭代器对象。

# 以下实例使用 yield 实现斐波那契数列：
def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print(next(f), end=" ")
    except StopIteration as e:
        print(e)
        if (e.value == None):
            break


# 类：类定义
class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))

    def __foo(self):          # 私有方法
        print('这是私有方法')


# 实例化类
p = people('runoob', 10, 30)
p.speak()
# print (p.__weight)  # 报错，实例不能访问私有变量
# p.__foo() # 报错 外部不能调用私有方法


# 单继承示例
class student(people):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))


s = student('ken', 10, 60, 3)
s.speak()


# 另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''

    def __init__(self, n, t):
        self.name = n
        self.topic = t

    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))


# 多继承
class sample(speaker, student):
    a = ''

    def __init__(self, n, a, w, g, t):
        student.__init__(self, n, a, w, g)
        speaker.__init__(self, n, t)


test = sample("Tim", 25, 80, 4, "Python")
test.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法

# 类的专有方法：
# __init__ : 构造函数，在生成对象时调用
# __del__ : 析构函数，释放对象时使用
# __repr__ : 打印，转换
# __setitem__ : 按照索引赋值
# __getitem__: 按照索引获取值
# __len__: 获得长度
# __cmp__: 比较运算
# __call__: 函数调用
# __add__: 加运算
# __sub__: 减运算
# __mul__: 乘运算
# __truediv__: 除运算
# __mod__: 求余运算
# __pow__: 乘方