Python

Python

基本数据类型

• 整数

• 浮点数

  /除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数,还有一种除法是//，称为地板除，两个整数的除法仍然是整数。

• 字符串
  '''...'''多行输出
  r...表示r后面的字符原样输出
  

  如：print(r'\\\t\\')输出为：\\\t\\

hello = "hello world!"
print(hello[2])  # l
print(hello[0 - 4])  # r
print(hello[0:-1])  # hello world

• 布尔值
  True、False,布尔值可以用and、or和not运算。
• 空值
  空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
• x ** y：x的y次幂
  abs(x)：x的绝对值
  print(divmod(x, y))：(x // y, x % y)
  pow(x,y)：x的y次幂

list(数组)

list是一种有序的集合，可以随时添加和删除其中的元素。
和字符串一样，也可反向取值和区间取值。
用len()函数可以获得list元素的个数。

pop(i) 不带参删除末尾元素，带参为删除指定位置的元素
insert(index, element) 将元素插入到指定位置

arr = ["h", "e", "l", "l", "o"]
print(arr[1:4])  # ['e', 'l', 'l']
arr[2] = "e"
print(arr)  # ['h', 'e', 'e', 'l', 'o']
arr.pop(2)
print(arr)  # ['h', 'e', 'l', 'o']
arr.insert(1, "Y")
print(arr)  # ['h', 'Y', 'e', 'l', 'o']

tuple(元组)

tuple一旦初始化就不能修改,它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的。

val = (2, 3, 4, [5, 6, 7])
val[3][2] = 100
print(val)  # (2, 3, 4, [5, 6, 100])
# tuple不可变！但指向的list的内容可变，指向的list不可变。

dict

d = {"one": 1, "two": 2, "three": 3, "four": 4}
print(d["one"])  # 1
print(d.get("two"))  # 2
d["five"] = 5
print(d)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}

set

set是不可重复元素集合。

s1 = set(range(6))
print(s1)  # {0, 1, 2, 3, 4, 5}
s = {1, 1, 2, 3}  # 字面量定义方法
s.add(5)
print(s)  # {1, 2, 3, 5}

逻辑

条件判断

day = int(input("day:"))  # 输入的是字符串，需要使用int()方法转换成int类型
if day == 2:
    print("周二")
elif day == 3:
    print("周三")
else:
    print("其他")

if 2 in [1, 2]:
    print("进来了1")
if 2 in [1, 1]:
    print("进来了2")
# 进来了1

循环

遍历输出 list

for i in [1, 2, 3, 4, 5, 6]:
    print(i)

Python提供一个range()函数，可以生成一个整数序列

for i in range(10):
    print(i, end=" ")  # 输出不换行
# 0 1 2 3 4 5 6 7 8 9 

while循环

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)  # 2500

函数

默认参数

Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。

def fun(L=[]):  # 可指定参数默认值
    L.append("H")
    print(L)
fun()  # ['H']
fun()  # ['H', 'H']

修改如下：

def add_end(L=None):
    if L is None:
        L = []
    L.append('H')
    return L
print(add_end())  # ['H']
print(add_end())  # ['H']

可变参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum += n
    return sum
print(calc(1, 2, 3, 4))  # 10

在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。

*nums表示把nums这个list的所有元素作为可变参数传进去。

def sum(*numbers):
    value = 0
    for i in numbers:
        value += i
    return value
a1 = [1, 2, 3]
a2 = [4, 5, 6]
print(sum(*a1, *a2))  # 21

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **other):
    print("name:", name, "age:", age, "other:", other)
person("xiaoming", 16)  # name: xiaoming age: 16 other: {}
person("xiaoming", 16, city="beijing")  # person("xiaoming", 16, city="beijing")
extra = {'city': 'Beijing', 'job': 'Engineer'}
person("xiaohua", 18, **extra)  # name: xiaohua age: 18 other: {'city': 'Beijing', 'job': 'Engineer'}

**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**other参数，kw将获得一个dict，注意other获得的dict是extra的一份拷贝，对other的改动不会影响到函数外的extra。

命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

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

和关键字参数**other不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

命名关键字参数必须传入参数名，这和位置参数不同。

def person(name, age, *, city="beijing", job):
    print(name, age, city, job)
person("xiaoming", 16, job="teacher")  # xiaoming 16 beijing teacher

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了。

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

异常