Python入门

拾忆
2021-05-06 / 0 评论 / 82 阅读 / 正在检测是否收录...

人生苦短,我用 Python

安装


基础操作

查看 Python 版本

$ python -V

使用 Python

可以通过以下命令进入环境:

$ python
Python 3.9.5 (tags/v3.9.5:0a7dcbd, May  3 2021, 17:27:52) [MSC v.1928 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>


基本数据类型

数据类型

# Number (单行注释)

1 + 1       # 2
1 - 1       # 0
1 * 1       # 1
4 / 2       # 2.0
9 // 2      # 4 (除法并取整)
9.0 // 2.0  # 4.0 (除法并取整,浮点数同样有效)
7 % 3       # 1  (取余)
2 ** 3      # 8 (2 的 3 次方)

# Boolean

True       # True
False      # False
not True   # False
not False  # True

True and False # False
True or False  # True

True + True  # 2
True + False # 1

0 == False # True
1 == True  # True
2 == True  # False

bool(-6)  # True
bool(0)   # False
bool("")  # False
bool([])  # False
bool({})  # False
bool(())  # False

# String

"string" # 'string'
'string' # 'string'

"Hello " + "world!"  # 'Hello world!'
"Hello " "world!"    # 'Hello world!'
"Hello world!"[0]    # 'H'
len("string")        # 6 (字符串长度)

name = "o2"   # 变量
f"{name} lab" # o2 lab (这里类似 ES6 里的模板字符串)

# None 

None # None
"etc" is None  # False
None is None   # True

List(列表)

List(列表)是一种有序的集合,可以随时添加和删除其中的元素。

name = ['aotu', 'lab', 'hello', 'kitty']

# 通过索引来访问列表中的数据
print(name[1]) # lab

# 截取数据
print(name[0:2]) # ['aotu', 'lab']

# 通过索引更新数据
name[1] = 'newbee'
print(name) # ['aotu', 'newbee', 'hello', 'kitty']

# 使用 append() 来添加列表项
name.append('world')
print(name) # ['aotu', 'newbee', 'hello', 'kitty', 'world']

# 使用 del 语句删除列表内的元素
del name[2]
print(name) # ['aotu', 'newbee', 'kitty', 'world']
函数&方法描述
len(list)列表元素个数
max(list)返回列表元素最大值
min(list)返回列表元素最小值
list(seq)将元组转换为列表
list.append(obj)在列表末尾添加新的对象
list.count(obj)统计某个元素在列表中出现的次数
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj)从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)将对象插入列表
list.pop(obj=list[-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj)移除列表中的一个元素(参数是列表中元素),并且不返回任何值
list.reverse()反向列表中元素
list.sort([func])对原列表进行排序

Tuple (元祖)

Tuple一旦初始化就不能修改,所以它是不可变的。它和TypeScript里的Tuple相似,区别在于TypeScript里的元祖的值类型一般为String或Number。

# 创建元祖
tuple1 = (1, 2, 3)

# 创建空元祖
tuple2 = ()

# 元祖只有一个元素时,需在后面添加逗号,否则会创建一个值为 1 的变量
tuple3 = (1,)

# 访问元祖的元素
print(tuple1[0]) # 1

# 元祖内的元素不能删除,但可以删除整个元祖
del tuple2
方法描述
len(tuple)元祖元素个数
max(tuple)返回元祖元素最大值
min(tuple)返回元祖元素最小值
tuple(seq)将列表转换为元祖

Dict(字典)

Dict(字典)类似于 JavaScript 里的 object 。

empty_dict = {}
filled_dict = {"one": 1, "two": 2, "three": 3}

差别:

方法和函数描述
len(dict)计算字典元素个数
str(dict)输出字典可打印的字符串表示
type(variable)返回输入的变量类型,如果变量是字典就返回字典类型
dict.clear()删除字典内所有元素
dict.copy()返回一个字典的浅拷贝
dict.values()以列表返回字典中的所有值
popitem()随机返回并删除字典中的一对键和值
dict.items()以列表返回可遍历的(键, 值)元组数组

Set

和其他语言类似,Set 是一个无序不重复的元素集合。

# 创建 set
set1 = set([1, 2, 3])
set2 = set([2, 3, 4, 5])

# 交集
set3 = set1 & set2 # {2, 3}

# 并集
set4 = set1 | set2 # {1, 2, 3, 4, 5}

# 差集
set5 = set1 - set2 # {1}

2 in set2 # True
方法描述
set.add(key)添加元素到set中
set.remove(key)从 set 中删除元素,如果元素不存在则会引发 KeyError
set.discard(key)如果元素存在集合中则将其删除
set.pop()从集合中移除并返回任意一个元素,如果集合为空则会引发 KeyError
set.clear()从集合中移除所有元素
set.copy()返回一个 set 的浅拷贝

条件语句与循环语句

条件语句

Python 中,if 语句基本形式如下:

if 判断条件:
    执行语句
else:
    执行语句
if 判断条件1:
    执行语句
elif 判断条件2:
    执行语句
elif 判断条件3:
    执行语句
else:
    执行语句

例子:

some_var = 5

if some_var > 5:
    print("some_var 大于 5")
elif some_var < 5:
    print("some_var 小于 5")
else:
    print("some_var 等于 5")

循环语句

循环语句有两种,一种是 for ... in ... 的形式:

for 元素 in 范围:
    执行语句

例:

# 遍历数字
# range(x) 函数,可以生成一个从 0 到 x-1 的整数序列
# range(a, b) 函数,可以生成一个从 a 到 b-1 的左闭右开整数序列
# range(a, b, g) 函数,可以生成一个从 a 到 b-1 的左闭右开整数序列,每次间隔为 g,例:range(0, 10, 2),意为从 0 到 10(不取10),每次间隔为 2
for i in range(3):
    print(i)

""" (多行注释)
0
1
2
"""

# 遍历字典
dict = {"a": "A", "b": "B", "c": "C"}
for i in dict:
    print(i)

""" 
a
b
c
"""

# 遍历元祖
for i in (3, 4):
    print(i)

""" 
3
4
"""

# 遍历列表
for i, value in enumerate(["hello", "world"]):
    print(i, value)

""" 
0 hello
1 world
"""

while 语句:

x = 0

while x < 4:
    print(x)
    x += 1

""" 
0 
1 
2
3
"""

函数

函数的概念不多做解释,下面是 Python 的函数写法:

def 函数名(参数1, 参数2...参数n):
    函数体
    return 语句
例:

# 参数可以设置默认值
def sum(x, y = 1):
    s = x + y
    return s

sum(2)    # 3
sum(2, 3) # 5

# 使用 *args 表示不定长参数,类似 JavaScript 里的 ...rest 参数,区别是 args 的类型是一个元祖,而 rest 是一个数组。
def varargs(*args):
    return args

varargs(1, 2, 3) # (1, 2, 3)


# 一般约定函数名使用下划线命名法
# 使用 **keyargs 表示可变长参数
def keyword_args(**keyargs):
    return keyargs

keyword_args(a = 3, b = 4) # {"a": 3, "b": 4}


# 返回多个参数
def swap(x, y)
    return y, x

a = 1
b = 2
b, a = swap(a, b)

在 Python 中也可以写匿名函数:

(lambda x: x > 2)(3)                 # True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # 5

# 内置高阶函数
list(map(max, [1, 2, 3], [4, 2, 1])) # [4, 2, 3]
list(filter(lambda x: x > 5, [3, 4, 8, 9])) # [8, 9]

类的定义和调用

类是一系列变量和方法的集合包,Python 中的类写法如下:

# 一般约定类名首字母大写,且使用驼峰式命名
class Human:

    # 静态属性
    species = "newbee"

    # 构造函数,self类似 JavaScript 里的 this
    def __init__(self, name):
        self.name = name

        # 初始化属性
        self._age = 0

    # 析构函数,当实例被销毁时调用
    def __del__(self):
        print("实例被销毁了")

    # 类的实例方法,第一个参数为 this 上下文(JS语境下)
    def say(self, msg):
        print("{name}: {message}".format(name=self.name, message=msg))

    # 类的实例方法,第一个参数为类本身
    @classmethod
    def get_species(cls):
        return cls.species

    # 类的静态方法
    @staticmethod
    def grunt():
        return "grunt"

    # 类似 getter 的属性定义
    @property
    def age(self):
        return self._age

    # 属性的 setter 方法
    @age.setter
    def age(self, age):
        self._age = age

    # 设置 deleter 允许该属性被删除
    @age.deleter
    def age(self):
        del self._age

# 此处 __name__ 是一个系统变量,可以用来检查一个模块是否为主程序模块
if __name__ == "__main__":
    # 实例化 Human 类
    i = Human(name = "chen")
    j = Human("liu")
    i.say("hi")         # "chen: hi"
    j.say("hi")         # "liu: hi"

    # 调用类实例方法
    i.say(i.get_species()) # "chen: newbee"

    Human.species = "big newbee"

    i.say(i.get_species()) # "chen: big newbee"

    # 调用静态方法
    print(Human.grunt()) # "grunt"
    # 实例也可以调用静态方法
    print(i.grunt()) # "grunt"

    # 修改属性
    i.age = 26
    i.say(i.age) # "chen: 26"
    j.say(j.age) # "liu: 0"

    # 删除属性
    del i.age

类的继承

Python 中所有的类都是继承自 object 类,所以上面例子中的 Human 类也可以写成下面的写法:

class Human(object):
    ...

继承 Human 类:

class Man(Human):

    # 子类可以覆盖父类的属性
    species = "Man"

    def __init__(self, name, age):

        self._age = age

        # 调用父类的构造函数
        super().__init__(name)

    # 覆盖父类的 say 方法
    def say(self):
        print("I am a man!")

    # 自定义子类的方法
    def code(self):
        print("I am coding!")

Python 支持多继承,方法在父类中未找到时,从左至右查找父类中是否包含方法。

class Woman(Human):
    species = "Woman"

    def __init__(self, name, age):
        self._age = age
        super().__init__(name)

    def birth(self):
        print("new child()")

# 多继承
class Ladyman(Man, Woman):
    species = "Ladyman"

    def __init__(self, name, age):
        self._age = age
        super().__init__(name)

    def birth(self):
        print("sos")

类型判断

使用 isinstance() 方法判断子类类型:

if __name__ == "__main__":
    person1 = Human("God")
    person2 = Man("Adam")
    person3 = Woman("Eve")

    print(isinstance(person1, Human)) # True
    print(isinstance(person2, Human)) # True
    print(isinstance(person1, Man))   # True
    print(isinstance(person1, Woman)) # False

    # isinstance() 也可用于判断基本类型
    print(isinstance("000", str)) # True
    print(isinstance(121, int))   # True
    print(isinstance(121, str))   # False

模块与标准库

模块

在 Python 中,一个 .py 文件就称之为一个模块(module)。

使用 import 关键字导入模块,如:

# 导入 math 标准库
import math

print(math.pi) # 3.141592653589793
import 默认导入该模块下所有属性和方法,类似 JavaScript 中:

import math from 'math.js'

我们知道在 JavaScript 中可以导入部分方法,在 Python 中同样可以:

from math import ceil, floor

print(ceil(3.7))  # 4.0
print(floor(3.7)) # 3.0

修改模块别名:

import math as m

math.sqrt(16) == m.sqrt(16) # True
1

评论 (0)

取消