Python 入门 - 基础语法参考

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

r = 2.5
s = 3.14 * r ** 2
print(f'The area of a circle with radius {r} is {s:.2f}')

# x是非零数值、非空字符串、非空list等，就判断为True，否则为False
if x:
    print('True')


age = 20
if age >= 18:
    print('your age is', age)
    print('adult')

age = 3
if age >= 18:
    print('your age is', age)
    print('adult')
else:
    print('your age is', age)
    print('teenager')

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

score = 'B'

match score:
  case 'A':
    print('score is A.')
  case 'B':
    print('score is B.')
  case 'C':
    print('score is C.')
  case _: # _表示匹配到其他任何情况
    print('score is ???.')

age = 15

match age:
  case x if x < 10:
    print(f'< 10 years old: {x}')
  case 10:
    print('10 years old.')
  case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:
    print('11~18 years old.')
  case 19:
    print('19 years old.')
  case _:
    print('not sure.')

args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']

match args:
  # 如果仅出现gcc，报错:
  case ['gcc']:
    print('gcc: missing source file(s).')
  # 出现gcc，且至少指定了一个文件:
  case ['gcc', file1, *files]:
    print('gcc compile: ' + file1 + ', ' + ', '.join(files))
  # 仅出现clean:
  case ['clean']:
    print('clean')
  case _:
    print('invalid command.')

names = ['Michael', 'Bob', 'Tracy']
for name in names:
  print(name)

sum = 0
n = 99

while n > 0:
  sum = sum + n
  n = n - 2

print(sum)

d = {'a': 1, 'b': 2, 'c': 3}

# 默认迭代 key
for key in d:
  print(key)

# 迭代 value
for key in d.values():
  print(key)

# 迭代 key value
for k, v in d.items()
  print(key)

# enumerate函数可以把一个list变成索引-元素对，这样就能同时迭代索引和元素本
for i, value in enumerate(['A', 'B', 'C']):
  print(i, key)

from collections.abc import Iterable


isinstance('abc', Iterable)     # True
isinstance([1,2,3], Iterable)   # True
isinstance(123, Iterable)       # False

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael'] #95  访问
d['Bob'] = 80 # 修改
d['Jack'] # 不存在 - 报错

# 判断
if 'Thomas' in d
  print('OK')

# 获取 不存在得到 None
d.get('Thomas')

# 若不存在则获得 -1
d.get('Thomas', -1)

# 删除
d.pop('Bob')

s = {1, 2, 3}
# 通过 list 作为输入
s = set([1, 2, 3])

# 添加元素
s.add(4)

# 移除元素
remove(key)

# set 可以做运算
s1 = {1, 2, 3}
s2 = {2, 3, 4}

s3 = s1 & s2    # {2, 3}
s4 = s1 | s2    # {1, 2, 3, 4}

def my_abs(x):
  if x >= 0:
    return x
  else:
    return -x

print(my_abs(-99))

def nop():
  pass

def power(x, n=2):
  s = 1
  while n > 0:
    n = n - 1
    s = s * x
  return s

power(5)
power(5, 2)
power(5, 3)

def calc(*numbers):
  sum = 0
  for n in numbers:
    sum = sum + n * n
  return sum

calc(1, 2)
calc(1, 2, 3)
calc(1, 2, 3, 4)

nums = [1, 2, 3]
calc(*nums)

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

person('Michael', 30)
person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')

def person(name, age, *, city, job):
  print(name, age, city, job)

person('Jack', 24, city='Beijing', job='Engineer')

def person(name, age, *args, city, job):
  print(name, age, args, city, job)

person('Jack', 24, city='Beijing', job='Engineer')

def person(name, age, *, city='Beijing', job):
  print(name, age, city, job)

person('Jack', 24, job='Engineer')

def f1(a, b, c=0, *args, **kw):
  print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
  print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']

# 取前3个元素，用一行代码就可以完成切片，从索引 0 开始取，直到索引 3 为止，但不包括索引 3
L[0:3]  # ['Michael', 'Sarah', 'Tracy']
L[1:3]  # ['Sarah', 'Tracy']
L[-2:]  # ['Bob', 'Jack']

L = list(range(100))  # 先创建一个0-99的数列
L[:10]    # 取前10个数
L[-10:]   # 取后10个数
L[10:20]  # 前11-20个数
L[:10:2]  # 前10个数，每两个取一个  [0, 2, 4, 6, 8]
L[::5]    # 所有数，每5个取一个
L[:]      # 原样复制一个 list

# 生成 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list(range(1, 11))

# 生成 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[x * x for x in range(1, 11)]

# 生成 [4, 16, 36, 64, 100]   加上if判断，筛选出仅偶数的平方
[x * x for x in range(1, 11) if x % 2 == 0]

# 生成 ABC 与 XYZ 的全排列 ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
[m + n for m in 'ABC' for n in 'XYZ']

# 列出当前目录下的所有文件和目录名
[d for d in os.listdir('.')]

# 列表生成式也可以使用两个变量来生成list
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]

# 把一个list中所有的字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]

L = [x * x for x in range(10)]
g = (x * x for x in range(10))
print(g)

# 使用 for 迭代
for n in g:
  print(g)


# 普通函数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

# generator 函数
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

# 正常
def inc():
  x = 0
  def fn():
    # 仅读取x的值:
    return x + 1
  return fn

f = inc()
print(f()) # 1
print(f()) # 1

# 报错
def inc():
  x = 0
  def fn():
    # 写入
    x = x + 1
    return x
  return fn

f = inc()
print(f()) # 1
print(f()) # 2

# 报错
def inc():
  x = 0
  def fn():
    nonlocal x
    x = x + 1
    return x
  return fn

f = inc()
print(f()) # 1
print(f()) # 2

# [1, 4, 9, 16, 25, 36, 49, 64, 81]
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

# lambda x: x * x 等价于如下函数
def f(x):
  return x * x

# 匿名函数可以赋值给一个变量
f = lambda x: x * x

# 匿名函数可以作为返回值返回
def build(x, y):
  return lambda: x * x + y * y

def log(func):
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper

# 相当于 now = log(now)
@log
def now():
    print('2024-6-1')

# 调用 now() 方法将执行 log() 函数中返回的 wrapper() 函数
now()

def log(text):
  def decorator(func):
    def wrapper(*args, **kw):
      print('%s %s():' % (text, func.__name__))
      return func(*args, **kw)
    return wrapper
  return decorator

# 相当于 now = log('execute')(now)
@log('execute')
def now():
    print('2024-6-1')

now()
# execute now():
# 2024-6-1

import functools

def log(func):
  @functools.wraps(func)
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper

mymodule
├─ __init__.py
├─ abc.py
└─ xyz.py

import os
import sys

print(sys.argv)
print(os.listdir('.'))

def _private_1(name):
    return 'Hello, %s' % name

def _private_2(name):
    return 'Hi, %s' % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

# 定义 Student 类
class Student(object):
  def __init__(self, name, score):
    self.name = name
    self.score = score
  
  def print_score(self):
    print('%s: %s' % (self.name, self.score))

  def get_grade(self):
    if self.score >= 90:
      return 'A'
    elif self.score >= 60:
      return 'B'
    else:
      return 'C'

bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()

class Student(object):
  def __init__(self, name, score):
    self.__name = name
    self.__score = score

  def print_score(self):
    print('%s: %s' % (self.__name, self.__score))

bart = Student('Bart Simpson', 59)

class Student(object):
  def __init__(self, name, score):
    self.__name = name
    self.__score = score

  def get_name(self):
    return self.__name

  def get_score(self):
    return self.__score

  def set_score(self, score):
    self.__score = score

  def print_score(self):
    print('%s: %s' % (self.__name, self.__score))

bart = Student('Bart Simpson', 59)

class Student(object):
  name = 'Student'

s = Student() # 创建实例s
print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
# Student
print(Student.name) # 打印类的name属性
# Student
s.name = 'Michael' # 给实例绑定name属性
print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
# Michael
print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
# Student
del s.name # 如果删除实例的name属性
print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
# Student

# 错误示例。不要这样做
class Student(object):
  name = 'Student'
  def __init__(self, name):
    self.name = name

class Student(object):
  __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

class Student(object):
  @property
  def score(self):
    return self._score

  @score.setter
  def score(self, value):
    if not isinstance(value, int):
      raise ValueError('score must be an integer!')
    if value < 0 or value > 100:
      raise ValueError('score must between 0 ~ 100!')
    self._score = value

class Animal(object):
    pass

# 大类:
class Mammal(Animal):
    pass

class Bird(Animal):
    pass

class Runnable(object):
    def run(self):
        print('Running...')

class Flyable(object):
    def fly(self):
        print('Flying...')

class Dog(Mammal, Runnable):
    pass
class Bat(Mammal, Flyable):
  pass

from enum import Enum

Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

from enum import Enum, unique

@unique
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

try:
  print('try...')
  r = 10 / 0
  print('result:', r)
except ValueError as e:
  print('ValueError:', e)
except ZeroDivisionError as e:
  print('ZeroDivisionError:', e)
  logging.exception(e)
finally:
  print('finally...')
print('END')

try:
  print('try...')
  r = 10 / 0
  print('result:', r)
except ValueError as e:
  print('ValueError:', e)
except ZeroDivisionError as e:
  print('ZeroDivisionError:', e)
finally:
  print('finally...')
print('END')

class FooError(ValueError):
    pass

def foo(s):
    n = int(s)
    if n==0:
        raise FooError('invalid value: %s' % s)
    return 10 / n

foo('0')

def foo(s):
  n = int(s)
  assert n != 0, 'n is zero!'
  return 10 / n

def main():
  foo('0')

f = open('/path/to/file', 'r')
# 读取文件内容
f.read()
# 每次最多读取 100 个字节的内容
f.read(100)
# 每次读取一行内容
f.readline()
# 一次读取所有内容并按行返回list
f.readlines()

# 传入标识符'w' 以写的模式打开文件
f = open('/path/to/file', 'w')
f.write('Hello, world!')