Skip to content

Latest commit

 

History

History
459 lines (380 loc) · 13.4 KB

README.md

File metadata and controls

459 lines (380 loc) · 13.4 KB
Raw

Python基础

本文为Python的一些基础知识总结，基于Python 3。

Types 类型

Basic Types 基础变量类型

  • int
  • float
  • str
  • bool

Type conversion 类型转换

使用 type(*) 用来获得变量类型，help(*) 可以获得帮助说明。

float(7)  # => 7.0
int(7.24) # => 7
int('A')  # error, 不能强转非数字的字符
str(2)    # => "2"
bool(1)   # => True

Grammar 基本语法

Expression 表达式

Mathematical Operations 数学运算

Python 3中，/ 和 // 代表的除法含义不同：

  • / 表示浮点数除法
  • // 为除法后的结果向下取整
f1 = 3 / 2  # => 1.5
f2 = 3 // 2 # => 1

String operations 字符串操作

Define a string 定义字符串

  • 对于简单字符串，可以使用单引号或双引号来表示 "", ''
  • 对于字符串中出现的相同引号，需要用 \ 来转义
  • 可以使用三重引号来避免转义
s1 = "Kevin"
s2 = 'Kevin' # s2 同 s1

S3 = """Kevin and "K.K".""" # => Kevin and "K.K".
  • 三重引号也可以用来实现多行注释
def add(x, y):
  '''Add two object(x, y) --> object(x + y)
  Return two var to one var
  '''
  return x + y
name[0]  # => 'K'
name

String slicing 字符串切片

Python string的语法定义为 string[start:end:step]，其中start默认为0，end默认为len(string)，step默认为1。

使用 str[i:j] 的方式来获取子字符串，其表示从索引i开始截止到（不含）索引j的字符

  • i >= -len(str)
  • j > i
s1 = "Kevin"
s1[0:2] # => "Ke"

s2 = "012345678"
s2[:5]      # => "01234"
s2[2:]      # => "2345678"
s2[2:5]     # => "234"
s2[2:7:2]   # => "246"

List的slicing:

a = [1, 2, 3]
a[1:]       # => [2, 3]
a[1:2]      # => [2] 注意这是取一个sub-list
a[1]        # => 2   而这是取一个元素

String Concatenation 字符串连接

可以用str0 + str1的方式连接字符

s0 = "I am "
s1 = "Kevin"
s2 = s0 + s1 # => "I am Kevin"

String replication 字符串复制

num * string的方式复制字符串为多次

s1 = "Kevin "
s2 = 3 * s1 # => "Kevin Kevin Kevin "

String is immutable 字符串的值是不可变的

不能改变一个字符串里的值，但可以对变量重新赋值。

s1 = "Kevin "
s1[0] = 'K' # ERROR!!!
s1 = "Wen"  # OK

String functions 字符串常用函数

  • str.upper()
  • str.replace(from_str, to_str)
  • str.find(sub_str)，返回第一次出现的index，没找到返回-1

Lists and Tuple 列表和元组

Tuple 元组

  • Tuple是有序的序列
  • Tuple可以含有不同的基本类型，例如string、int、float、bool等
  • 使用圆括号 (*, *)
  • Tuple里可以只包含一个元素，但此时逗号不可以省略
t = ('Kevin',) # 此时t是元组
s = ('Kevin')  # 此时s是字符串，相当于 s = 'Kevin'

Tuple properties 元组属性

  • 可以使用索引的方式访问tuple[i]
  • 合并：tuple3 = tuple1 + tuple2
  • 支持slicing
  • 同样immutable

Tuple Nesting 元组嵌套

Tuple的一个item可以是Tuple

tuple0 = (1, 2, ("pop", "rock"), (3, 4))
tuple0[2]     # => ("pop", "rock")
tuple0[2][1]  # => "rock"`

List 列表

  • List是有序的序列
  • List可以含有不同的基本类型，例如string、int、float、bool等
  • 使用方括号 [*, *]

List properties 列表属性

  • 支持索引访问
  • 合并：list3 = list1 + list2
    • 等于list3 = list1, list3.extend(list2)
    • 注意：append与extend不同，被append的item是作为一个整体追加到list末尾，例如L.append(["pop", 10])后，L中多了一个元素["pop", 10]
  • 支持slicing
  • 支持Nesting 嵌套
  • mutable，元素可被修改
    • 对某个元素重新赋值：L[0] = 0
    • del(L[0])即可删除某个item

Covert String to List 转换字符串到列表

string.split()：按照空格拆分字符串

"Kaikai is a dog".split()     # => ['Kaikai', 'is', 'a', 'dog']
"Kaikai,is,a,dog".split(",")  # => ['Kaikai', 'is', 'a', 'dog']

List Aliasing 列表别名

如果一个变量B指向另一个变量A (B = A)，那么B是A的别名。对A的任何改动，B都可以访问到。

l1 = [1, 2, 3]
l2 = l1
l1[0] = 0
print(l1) # [0, 2, 3]
print(l2) # [0, 2, 3]

List Clone 列表复制

复制一个列表通过 B = A[:]的方式，A和B相互不影响

l1 = [1, 2, 3]
l2 = l1[:]
l1[0] = 0
print(l1) # [0, 2, 3]
print(l2) # [1, 2, 3]

Dictionary 字典

Dictionary中的每个元素由(key, value)的键值对组成。

  • 使用花括号来表示{}来表示。
  • Key是唯一的，并且不可修改
  • value可以是可修改的/不可修改的，可重复的
  • 每个item之间用逗号隔开
  • 访问
    • 使用dict[key]的方式来访问value
  • 新增
    • 直接对一个dict[key]赋值
  • 删除
    • del(dict[key])
  • 获取所有keys或values
    • dict.keys()
    • dict.values()
dic = {"k1":1, "k2":"2", "k3":[3,3], "k4":(4,4), ('k5'):5}

Sets 集合

Sets 是类似list和tuple的集合，可以包含任意元素。

  • 使用花括号来表示{}来表示。
  • Unordered：Sets是无序的
  • Unique：Sets里的元素值是唯一的
  • 创建
    • 通过类型转换：set(a_list)
  • 新增
    • s.add(item)
  • 删除
    • s.remove(item)
  • 两个集合的交集
    • s0 & s2
  • 两个集合的合集
    • s0
  • 测试是否包含某个元素
    • item in s
  • 测试是否是子集
    • s0.issubset(s1)

Conditions and Branching 条件和分支

Conditions 条件

  • ==, <=, >=, >, <, !=
    • 比较int、float、double、string、list等都可以
    • 尤其是==可用来比较值/元素是否相同
  • or / and

Branching 分支

  • if (...), elif(...), else:

Loops 循环

range([start], end, [step])

  • 产生从0开始的一个序列直到end -1，每个值之间相差step， step可省略，默认为1，

for i in range(N):

  • 循环0, 1, ..., N-1

for i in range(1, 10, 2):

  • 1, 3, 5, 7, 9

while (condition):

Functions 函数

函数是有输入和输出的代码集合，主要目的是为了复用，同时让代码结构更清晰。 Python 中函数的定义使用关键词def function_name():

Build in functions 内置函数

  • len(): 长度、元素个数
  • sum()：元素求和
  • sorted()：将collection的元素排序的结果返回，原collection不受影响

Collecting arguments 多参数

参数前可以有1个或2个星号，这两种用法其实都是用来将任意个数的参数导入到python函数中。

  • def foo(param1, *agrs):：
    • 将所以参数以元组(tuple)的形式导入
    def foo(param1, *param2):
  print(param1) # => 1
  print(param2) # => (2, 3, 4, 5)
foo(1,2,3,4,5)
  • def bar(param1, **kwargs):：
    • 将参数以字典的形式导入
    def bar(param1, **param2):
  print(param1) # => 1
  print(param2) # => {'a': 2, 'b': 3}
bar(1, a=2, b=3)

Scope 作用域

Python 中变量区分局部和全局作用域，同 C++ / Java 之类的语言。 如果在函数中希望定义全局变量，可以在变量前加关键字global，以便在全局可被访问。

Objects and Classes 对象和类

  • 类(Class): 用来描述具有相同的属性(Data attributes)和方法(methods)的对象的集合。
    • 定义：
      • class ClassName ([ParentClassName]):
    • 构造函数或初始化方法：
      • def __init__(self, name, salary):
  • 对象(Object)：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
    • 创建：
      • varName = ClassName ([parameters])
  • 方法(Method)：类中定义的函数

可以用dir(object)的方式列出类的属性。

File IO 文件操作

File open and close 文件打开关闭

  1. 读写格式

    • FileObject = open(file_path, mode)
      • 创建："x"，如果文件存在则返回失败
      • 只读："r"
      • 覆写："w"
      • 追加："a"
      • 文本："t" ，为默认值
      • 二进制："b" ，例如读写图片

  2. 关闭文件

    • file.close()
    • 推荐用with open(path, mode) as file:，在执行完with的作用域时自动调用file.close()。

Reading Files 读文件

  • file.read([n_characters])：
    • n_characters == 0: 读整个文件
    • 读n_characters个字符的内容
  • file.readline() ：读一行
  • file.readlines() ：读所有的行
with open("example.txt", "r") as file:
  content = file.read()
  print(content)

Writting Files 写文件

  • file.write(string)：
    • 写入一行内容
with open("example.txt", "w") as file:
  file.write("a line")

Delete a File or Folder 删除文件或目录

  • 删除一个文件或目录：
    • os.remove("filename_or_foldername")

函数变量

局部变量和全局变量

有其他语言经验的朋友对这两点一定很容易理解这两点。只是想提醒一下，避免global的全部变量，毕竟让code很难维护。下面说说模块导入变量。

模块导入变量

核心思想是把同一个全局模块的内容组织到一个py文件中，通过模块导入的方式共享到相同模块的代码中：

看例子，在main.py中：

import global_abc
import another

def print_variables():
    print(global_abc.GLOBAL_A + ", " + global_abc.GLOBAL_B)

if __name__ == '__main__':
    print_variables()       # Hello, Python

    global_abc.print_name() # Kevin
    global_abc.modify_name()# change Kevin --> GoGo
    global_abc.print_name() # GoGo
    another.print_name_in_3rd_module()  # GoGo

在global_abc.py中：

GLOBAL_A = 'Hello'
GLOBAL_B = 'Python'

name = 'Kevin'

def modify_name():
    global name
    name = 'GoGo'

def print_name():
    print(name)

在another.py中：

import global_abc

def print_name_in_3rd_module():
    global_abc.print_name()

通过这种方式，可以在多个不同的文件间组织和共享变量。

这部分的内容的组织方式自参考了文章[2]。

其他

Python 参数传递

Python函数参数前面单星号（*）和双星号（**）的区别

'''单星号（*）：*agrs：将所以参数以元组(tuple)的形式导入'''
def foo(param1, *param2):
    print(param1, param2)

'''双星号（**）：**kwargs：将参数以字典的形式导入'''
def bar(param1, **param2):
    print(param1, param2)
    
foo(1,2,3,4,5)
# output: 1 (2, 3, 4, 5)

bar(1,a=2,b=3)
# output: 1 {'a': 2, 'b': 3}

Reference

  1. Python 3 官方文档
  2. https://blog.csdn.net/Eastmount/article/details/48766861

回到目录