活了二十多年,没能为祖国、为人民做点什么,每思及此,伤心欲绝 !

Python语法速查,这些都会吗?

Python keguang 605℃ 0评论

Python 是一门独特的语言,快速浏览一下他的要点:

1)、面向对象:每一个变量都是一个类,有其自己的属性(attribute)与方法(method)。
2)、语法块:用缩进(四个空格)而不是分号、花括号等符号来标记。因此,行首的空格不能随意书写。
3)、注释:行内用“#”号,行间注释写在两组连续三单引号之间:’’’
4)、续行:行尾输入一个反斜杠加一个空格(’\ ‘),再换行。如果行尾语法明显未完成(比如以逗号结尾),可以直接续行。
5)、打印与输入: 函数 print() 与 input(),注意 print() 的 sep 与 end 参数。
6)、变量:无需指定变量类型,也不需要提前声明变量。
删除变量:del()
复制变量:直接将变量a赋值给b,有时仅仅复制了一个“引用”。此后 b 与 a 的改动仍会互相影响。必要时使用 a is b 来判断是否同址。
7)、模块:通过 import pandas 的方式加载模块(或者 import pandas as pd),并用形如 pandas.DataFrame(或 pd.DataFrame)的方式调用模块内的方法。也可以使用 from pandas import DataFrame 的方式,这样在下文可以直接使用 DataFrame 作为调用名。
8)、帮助:配合使用 dir() 与 help() 命令;其中前者是输出变量所有的成员。以及查阅 官网页面。

变量复制的一个例子。

a = [1, 2]
b = a
print(id(a) - id(b))  # 地址差为 0,表示实质是同址的
0
b.append(3)
print(a)  # 只改动了 b,但 a 也跟着变动了
[1, 2, 3]
a is b
True

使用切片来重新分配空间:

a is a[:]
False

数据结构

Python 原生的数据结构包括:

数字(num)

细分为整数(int)与浮点数(float)两种。

  • 四则运算:+, -, *, / ,乘方: **
  • 整除: 5 // 2 = 2,取余:5 % 2 = 1
  • 自运算: a += 1 (四则与乘方均可类似自运算)

以及一些细节:

  • 运算两数中只要有一个浮点数,结果就是浮点数;
  • 整数相除,即使能除尽,结果也是浮点数;
  • Python 内部的机制解决了整数溢出的问题,不用担心。

布尔(bool)与逻辑

首字母大写 True / False.

  • 逻辑运算符:与 A and B,或 A or B,非 not A
  • 逻辑关系符:等于 ==, 不等于 !=. 其他不赘述。
  • 几种逻辑判断例子:
变量 x x = [] x = 0 x = 2
bool(x) False False True
if x: … False False True
if x is None: … False False False

序列(sequence)

序列主要包括字符串(str)、列表(list)与元祖(tuple)三类。

  • 序列索引规则:
    • 索引从0开始,到 N-1 结束。
    • 切片:切片的索引是左闭右开的。
      • seq[0:2](从 0 到 1)
      • seq[2:](从 2 到尾)
      • seq[:3] (从头到 2)
      • seq[:](全部)
      • seq[:10:2](从头到9,每两个取一个)
      • seq[::2](全部,每两个取一个)
    • 索引允许负数:seq(-1) 与 seq(N - 1) 等同,seq(-3:-1)与 seq(N-3:N-1) 等同。
  • 序列通用函数:
    • len():返回序列长度。
    • +/* :加号用于连接两个序列,乘号重复排列若干次再连接。
    • seq1 in seq2:如果 seq1 这个片段可以在 seq2 中被找到,返回 True.
    • index:在 seq1 in seq2 为 True 时使用,seq2.index(seq1) 表示 seq1 首次出现于 seq2 中的位置。
    • max()/min():返回序列中的最值。如果不是数字,则按 ASCII 码顺序返回。
    • cmp(seq1, seq2):比较大小。结果为负,则表示 seq1 较小。

字符串(str)

写于一对双引号或单引号内。用 str() 可以强制转换为字符串。

  • 转义:反斜杠。如果强制不解释字符串,在左引号前加字母 r 即可: r"c:\new".
  • 分割与连接:**.split() 与 **.join().
s = " I love Python"  # 首位是空格
lst = s.split(' ')
lst1 = '-'.join(lst)

print(lst, '\n', lst1)
['', 'I', 'love', 'Python'] 
 -I-love-Python
  • 紧切:strip() 去掉字符串首尾两端的空格。方法 lstrip()/rstrip() 则只切除首端/尾端的空格。
s.strip()
'I love Python'
  • 大小写转换:如下几个方法:
    • 首字母大写:s.title()
    • 全大写:s.upper()
    • 全小写:s.lower()
    • 句首大写:s.capitalize()
  • 格式化:字符串格式化是一种实用功能。通过 .format() 成员函数完成。
'I like {} and {}'.format('Python', 'you')
'I like Python and you'
'{0} + {2} = {1}'.format (10, 20, 'Python ')  # 按顺序引用
'10 + Python  = 20'
'{0} * {1} = {0}'.format (10, 'Python ')  # 编号反复引用
'10 * Python  = 10'

格式化控制码:

控制码 含义 控制码 含义
:s 字符串 :c 单个字符
:b/o/x/d 二、八、十六、十进制数 :e/f 科学计数法/浮点数

一些复杂控制的例子:

例子 含义 例子 含义
:.2f/:+.2f 两位小数/带符号两位小数 : .2f 正数前补空格的两位小数
:, 逗号分隔符 :.2% 百分比两位小数
:.2e 科学计数法两位小数 :^4d 总宽四位居中对齐
:>4d/<4d 总宽四位左/右对齐 :0>4d 总宽四位左侧补零

举例:

"{:0>7.2f} is an odd number".format(123.4)  # 总宽 7 位小数点后 2 位,左侧补零
'0123.40 is an odd number'

其他实用的字符串函数:

  • str.replace(old, new[, times]):将字符串中前 times 个 old 子串替换为 new。Times 不指定时默认替换全部。
  • str.isdigit():判断字符串是否每一位都是数字,返回 True 或者 False。

字符串中正则表达式的内容参见本文附录。

列表(list)

中括号式的结构。list() 用于强制转换类型。

lst = [1, 2, 3]
print(lst)
[1, 2, 3]
# 【反转】:其中第二种方式会更改现有的列表
lst1 = list(reversed(lst))
lst.reverse()
print(lst1, lst)
[3, 2, 1] [3, 2, 1]
# 【追加】:元素 append(),另一个列表:extend()
lst.append(4)
print(lst)
[3, 2, 1, 4]
lst.extend(lst1)
print(lst)
[3, 2, 1, 4, 3, 2, 1]
# 【插入】:lst.insert(idx, obj) 会在 lst[idx] 处插入 obj,然后依次后移原有项
lst.insert(1, 100)
print(lst)
[3, 100, 2, 1, 4, 3, 2, 1]
# 【删除】:lst.remove(obj) 会删除首个匹配值,若无匹配会报错;
#           lst.pop(idx) 会返回 lst[idx],并将其删除。如果不指定 idx,默认为列表尾
lst.remove(2)
print(lst)
[3, 100, 1, 4, 3, 2, 1]
tmp = lst.pop()
print(lst, "\n", tmp)
[3, 100, 1, 4, 3, 2] 
 1
# 【搜索】:使用序列通用函数即可。用 count(obj) 可以计算频数。
# 【排序】:sort() 方法。如果指定 reverse 参数,可降序排序。
lst.sort(reverse=True)
print(lst)
[100, 4, 3, 3, 2, 1]
# 【清空】:clear()
lst.clear()
print(lst)
[]

元组(tuple)

圆括号式的结构,是一种不可变序列。

a = (1, 'string ', [1 ,2])
print(a)
(1, 'string ', [1, 2])

Note: 定义一个空的元组用(),定义只有一个元组的元组,需要加,,否则就不是元组了,如下:

>>> tuple1 = ()
>>> type(tuple1)
<type 'tuple'>
>>> tuple2 = (1)
>>> type(tuple2)
<type 'int'>
>>> tuple3 = (1,)
>>> type(tuple3)
<type 'tuple'>

字典(dict)

字典是一种类哈希表的数据结构,内部无序,通过键值对(key: value)的形式存储数据。几种字典初始化的方式:

# 小字典直接赋值
d1 = {"name": "wklchris", "gender": "male"}
# 利用字典增加键值对的方法
d2 = {}
d2['name'] = 'wklchris'
# 一个值赋给多个键
d3 = {}.fromkeys(("name", "gender"), "NA")
# 强制格式转换
d4 = dict(name="wklchris", gender="male")

print(d1, d2, d3, d4, sep="\n")
{'name': 'wklchris', 'gender': 'male'}
{'name': 'wklchris'}
{'name': 'NA', 'gender': 'NA'}
{'name': 'wklchris', 'gender': 'male'}

字典的操作方法:

len(d1)
2
# 【复制】:
dd = d1.copy()
dd is d1
False
# 【查找键名称】:
"name" in dd
True
# 【删除键值对】
del(dd["name"])
# 【get】
dd.get("name", "Nothing")  # 如果键不存在,返回“Nothing”
'Nothing'
# 【setdefault】
dd.setdefault("name", "wklchris")  # 如果键不存在,就新建该键,并赋值
'wklchris'
print(dd)
{'name': 'wklchris', 'gender': 'male'}
# 【输出键值】:
list(dd.items())
[('name', 'wklchris'), ('gender', 'male')]
list(dd.keys())
['name', 'gender']
list(dd.values())
['wklchris', 'male']
# 【弹出键值对】:pop(key) / popitem(key)
# 其中,后者会随机弹出一个键值对
tmp = dd.pop("gender")
print(dd, tmp)
{'name': 'wklchris'} male
# 【更新】:update(ref_dict) 以 ref_dict 为准,更新当前字典
d4 = {"name": "Test", "Age": 3}
dd.update(d4)
print(dd)
{'name': 'Test', 'Age': 3}

集合(set)

本文只讨论可变集合,关于不可变集合的内容,参考 help(frozenset)。

集合是一种无序的数据存储方式,且内部元素具有唯一性。集合与字典一样都可以用花括号的形式创立。但在书写 a={} 时,Python 会将其识别为字典类型。

  • 增添:add() / update()
  • 删除:remove() / discard(),区别在于后者搜索无结果会报错。
  • 从属:a.issubset(b) 集合 a 是否是 b 的子集;a.issuperset(b) 集合 a 是否是 b 的父集。a == b 两集合是否全等。
  • 集合运算:集合运算不会改变参与运算的集合本身。
    • 并集: a | b 或者 a.union(b)
    • 交集: a & b 或者 a.intersection(b)
    • 补集: a - b 或者 a.difference(b)
      注意:在字符串强制转换为集合时,必要时使用中括号先转为列表(否则字符串会被拆分为单个字符后再进行转换)。例如:
    • ss = {"a", "b", "c"}
      ss | set("de")
      {'a', 'b', 'c', 'd', 'e'}
      ss | set(["de"])
      {'a', 'b', 'c', 'de'}

基本语句

同大多数程序语言一样,Python 拥有 if, for, while语句。什么?switch 语句?使用字典就好。

if 语句与三元操作

在 Python 中,else if 被缩写为单个关键词 elif.

if 1.0 > 1:
    a = 1
elif 1.0 < 1:
    a = 2
else:
    a = 3
    
a
3

值得一提的是,Python 中的 if 语句支持链式比较,形如 a < x < b, a < x >= b 等:

a = 0
if 1 < 2 > 1.5:
    a = 1
a
1

三元操作实质是高度简化的 if 环境,形如 X = a if flag else b

a = 1 if 2 < 1 else 2
a
2

for 语句

Python 的循环语句中,像其他语言一样,有 break(跳出循环体) 与 continue(循环步进) 关键词可以使用。

for 语句借助关键词 in 使用:(函数 range(N, M=0, s=1) 是一个生成等差数列的函数,位于左闭右开区间[M,N)上且公差为 s)。

for i in range(3):
    print(i)
0
1
2

注意到字典的 d.items(), d.keys(), d.values() 命令也常常用于 for 语句:

d = {"a": 1, "b": 2, "c": 3}
for k, v in d.items():
    print(k, v)
b 2
c 3
a 1

以上等价于:

for k in d.keys():
    print(k, d[k])
b 2
c 3
a 1

Python 中的 for 语句可选 else 语法块,表示 for 语句正常结束后执行的内容(中途 break 不属于正常结束)。这对于处理一些 break 操作很有帮助。例如:

a = 0
flag = 0
for i in range(5):
    if i > 2:
        flag = 1
        break
if flag == 1:
    a = 1
a
1

这在 Python 中显得太复杂了,直接使用 for…else…即可:

a = 1
for i in range(5):
    if i > 1:
        break
else:
    a = 0
a
1

while 语句

while 语句的 else 语法块,指明了退出 while 循环后立刻执行的内容;它不是必需的。

如果你想要将 while 语句内部的参数传出(比如下例的计数器终值),这是一个不错的方案。

count = 1
while count < 5:
    a = count
    count *= 2
else:
    b = count

print(a, b)
4 8

列表解析

列表解析是一种创建列表的高度缩写方式:

lst = [x ** 2 for x in range(4)]
lst
[0, 1, 4, 9]

也可以配合 if 语句:

lst = [x ** 2 for x in range(4) if x > 0]
lst
[1, 4, 9]

类似的,也有字典解析,以及下文会介绍的生成器,也有生成器解析(把外围的括号换成圆括号即可):

{n: n ** 2 for n in range(3)}
{0: 0, 1: 1, 2: 4}

函数

本节介绍 Python 函数的基础特点,以及一些实用函数。

函数定义与判断

使用 def 关键字。三连双引号间的内容被视为函数的帮助字符串,可以通过 help() 命令查看。

def func(a, b=0):
    """
    This is a function that can meow.
    """
    return " ".join(["meow"] * (a + b))

调用函数:

func(2)  # 单参数,仅 a 
'meow meow'
func(2, 3)  # 双参数, a 与 b 都被传入
'meow meow meow meow meow'
help(func)
Help on function func in module __main__:

func(a, b=0)
    This is a function that can meow.

通过 callable() 可以判断一个对象是否是一个可调用的函数:

callable(func)
True

不定参函数

利用序列(或元组)与字典,向函数传参。前者在传入时需要加上一个星号,后者需要两个。

lst = [1, 3, 4]
d = {"a": 2, "b": 3, "c": 5}
print("{}+{}={}".format(*lst), "{a}+{b}={c}".format(**d))
1+3=4 2+3=5

zip 函数

zip() 函数的作用是“合并”多个列表为一个。其返回值是一个列表,列表内的元素类型是元组。如果待合并的列表长度不同,以最短的为准。

a = [1, 2, 3, 4]
b = [5 ,6, 7]
c = "abcd"
list(zip(a, b, c))
[(1, 5, 'a'), (2, 6, 'b'), (3, 7, 'c')]

它比较常用于交换字典的键与值:

dict(zip(d.values(), d.keys()))
{2: 'a', 3: 'b', 5: 'c'}

lambda 函数

一种匿名函数的声明方式。如果你使用过 MATLAB,你可能熟悉这一类概念。

func = lambda x, y: x + y
func(2, 5)
7

map 函数

map() 能够对传入的序列进行依次操作,并将结果返回为一个可转换为列表的 map 对象。通常列表解析(或生成器解析)可以实现与其同样的工作。

lst = list(map(lambda x: x + 1, range (5)))
print(lst)
[1, 2, 3, 4, 5]
f = lambda x: x + 1
[f(x) for x in range(5)]
[1, 2, 3, 4, 5]

filter 函数

给定序列,对于满足某规则的部分(即 True),予以返回。

list(filter(lambda x: x > 0, range(-3, 3)))
[1, 2]

reduce 函数

该函数在 Python 2 中是可以直接调用的,但在 Python 3 中需要从 functools 模块进行调用。

from functools import reduce
reduce(lambda x, y: x + y, range (5))  # 0+1+2+3+4
10

enumerate 函数

它允许你像 d.items() 那样,用类似的方式操作列表:

a = [1, 3, 5]
for i, v in enumerate(a):
    print("lst[{}] = {}".format(i, v))

lst[0] = 1
lst[1] = 3
lst[2] = 5

 

转载请注明:柯广的博客 » Python语法速查,这些都会吗?

喜欢 (1)or分享 (0)
发表我的评论
取消评论

表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址