Python入门

• 学习目标
• 安装Python
• Python基础
• • 输入输出
  • 数据类型
  • 方法、占位符
  • 列表
  • • List
    • tuple
  • 条件判断
  • 循环
  • • for...in循环
    • while循环
    • break打断循环
    • continue跳过循环
  • dict和set
  • • dict
    • set
  • 函数
  • 参数
  • • 位置参数
    • 默认参数
    • 可变参数
    • 关键字参数
    • 命名关键字参数
  • 递归函数
  • • 递归
    • 尾递归
• 高级特性
• • 切片
  • 迭代Iteration
  • 列表生成式
  • 生成器generator
  • 函数式编程
  • • 函数
    • • map
      • reduce
      • sorted()
    • 返回函数
    • lambda匿名函数
    • 装饰器
• 爬取豆瓣网栗子

学习目标

首先，为什么要学python呢？

1. 不想当全栈的程序员不是cool girl，java、C比较难，毕业半年还给老师了，基础python比较简单（没有说python简单的意思！！高级python以后再说)；
2. 装x；
3. 方便生活，因为python确实很好用。

有目标才有动力！

目标：学会基础python，学会爬虫，可以在百度上爬下来一篇小说或诗词。

安装Python

Python下载
cmd执行python查看是否安装成功，出现版本号则安装成功。

Python基础

跟着廖雪峰老师的教程过了一遍，Python教程 by 廖雪峰。
VSCode创建 0322.py文件。
cmd中执行。找到0322.py的目录，python 0322.py执行代码。

输入输出

# 输出
print("hello python")
# 输入
name = input("please enter your name:")
print("name:", name)

数据类型

整数、浮点数、字符串、布尔值（True、False）、空值（None）、变量（变量名必须是大小写英文、数字和_的组合，且不能用数字开头）、常量（在Python中，通常用全部大写的变量名表示常量）

# r''表示转义字符不转义
print(r"///demo")
# '''...'''表示多行内容
print('''lizi
是
小可爱''')

# 布尔值判断
print(5 > 3)

# 除法
print("/", 10/3)
# 地板除，取整
print("//", 10//3)
# 取余
print("%", 10%3)

方法、占位符

print("abcde的长度", len('abcde'))
# abcde的长度 5

print("hello, %s" %"world")
# hello, world

print('%.2f%%' % 24.2455)
# 24.25%

列表

List

内置数据类型
元素类型可以不同，也可以嵌套，如：["apple", "orange", "sweets", 2, [True, "22"]]

food = ["apple", "orange", "sweets"]
print("list的长度", len(food))
# list的长度 3
print("list第一个、第二个、倒数第一个元素", food[0], food[1], food[-1])
# list第一个、第二个、倒数第一个元素 apple orange sweets
# 末尾插入元素 append()
food.append("banana")
print(food)
# ['apple', 'orange', 'sweets', 'banana']
# 指定位置插入元素 insert()
food.insert(2, "bread")
print(food)
# ['apple', 'orange', 'bread', 'sweets', 'banana']
# 删除末尾元素 pop()
print(food.pop())
print(food)
# banana
# ['apple', 'orange', 'bread', 'sweets']
# 删除指定位置元素 pop(i)
print(food.pop(1))
print(food)
# orange
# ['apple', 'bread', 'sweets']
# 元素替换
food[0] = "peach"
print(food)
# ['peach', 'bread', 'sweets']

tuple

tuple无append()、insert()、pop()等方法，一经定义后不能改变。
只有一个元素时，省略小括号，非tuple类型。可以加个逗号，代表tuple类型。

people = ("Liz", "Andy", "Bob")
print(people)
# ('Liz', 'Andy', 'Bob')
test = ("Jim")
print(test)
# Jim
test2 = ("Jim", )
print(test2)
# ('Jim',)

条件判断

使用if...:...else:...

height = 24
if height > 30:
    print("1")
elif height > 5:
    print("2")
else:
    print("3")
# 2

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

# 输入
input()
# 字符串转换为整数
int()

循环

for…in循环

food = ["apple", "nut", "coke"]
for item in food:
    print(item)
# apple
# nut
# coke

# 0-num的整数序列
range(num)

while循环

num = 2
all = 3
while all > 0:
    num = num * num
    all = all - 1
print(num)
# 256

break打断循环

num = 2
all = 3
while all > 0:
    num = num * num
    all = all - 1
    if all < 2:
    	break
print(num)
# 16

continue跳过循环

n = 0
while n < 5:
    n = n + 1
    if n%2 == 0:
    	continue
    print(n)
# 1
# 3
# 5

dict和set

dict

dict全称dictionary，同map，使用键-值（key-value）存储，方便快速查找信息。

info = {"name": "Liz", "age": "18", "weight": "44kg"}
print(info["name"])
# Liz
info["height"] = "160cm"
print(info)
# {'name': 'Liz', 'age': '18', 'weight': '44kg', 'height': '160cm'}
print(info.get("height"))
# 160cm
print(info.pop("name"))
# Liz
print(info)
# {'age': '18', 'weight': '44kg', 'height': '160cm'}

set

一组key的集合，但不存储value，元素不能重复。

s = set([1, 2, 3, 2])
print(s)
# {1, 2, 3}
s.add(4)
s.remove(1)
print(s)
# {2, 3, 4}
a = set([1, 2, 5])
print(a & s)
# {2}
print(a | s)
# {1, 2, 3, 4, 5}

函数

python内置方法 官方

# python内置函数，abs()，求绝对值
print(abs(-10))
# 10

自定义函数：在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):
# isinstance()类型错误报错
	if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
print(my_abs(-2))
# 2
# 空函数pass，函数占位符
if a > 10:
	pass

参数

位置参数

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

默认参数

必选参数在前，默认参数在后。
默认参数必须指向不变对象

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

可变参数

def calc(*numbers):
    sum = 0
    for x in numbers:
        sum = sum + x*x
    return sum
print(calc(1, 2, 3))
# 14
nums = [1, 2, 3]
print(calc(*nums))
# 14

关键字参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
print(person("Liz", 18))
# name: Liz age: 18 other: {}
# None
extra = {'city': 'Beijing', 'job': 'Engineer'}
print(person('Jack', 24, **extra))
# name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
# None

命名关键字参数

分隔符*后面的参数为命名关键字参数

def person(name, age, *, city, job):
    print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')
# Jack 24 Beijing Engineer

数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
f1(1, 2, 3, 'a', 'b', x=99)
# a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

递归函数

递归

计算1x2x3x4x……n

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)
print(fact(3))
# 6

尾递归

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)
print(fact(3))
# 6

高级特性

切片

取对象n-m，Obj[n:m:l]（不包含m，每l个数取一个），n=0时可以省略。

people = ["Andy", "Lily", "Popi", "Uu", "Wendy"]
print(people[:4:2])
# ['Andy', 'Popi']

food = ("apple", "nuts", "banana", "strawberry", "chicken")
print(food[:3])
# ('apple', 'nuts', 'banana')

print("asdfghjkl"[::2])
# adgjl

迭代Iteration

使用for...in...循环迭代，in的内容需要判断是否是可循环迭代。

from collections.abc import Iterable
print(isinstance('asdf', Iterable))
# True

列表生成式

for前面的if ... else是表达式，而for后面的if是过滤条件，不能带else。

# 生成1-4
print(list(range(1, 5)))
# [1, 2, 3, 4]

# 生成1*1-4*4
print(list(i*i for i in range(1,5)))
# [1, 4, 9, 16]

# 小写、去掉非字符串
L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [x.lower() for x in L1 if isinstance(x, str)]
# ['hello', 'world', 'apple']

生成器generator

一边循环一边计算的机制。有以下方法生成生成器：

1. 将列表生成式的[]改成()

g = (x * x for x in range(3))
print(g)
print(next(g))
# <generator object <genexpr> at 0x000001BD81FC1270>
# 0
for i in g:
    print(i)
# 0
# 1
# 4

2. 一个函数定义中包含yield关键字

函数式编程

函数

函数的变量可以是函数，返回也可以是函数。

def add(x, y, f):
    return f(x) + f(y)
print(add(-5, 6, abs))
# 11

map

map（转换规则，即将被转换的参数）

def fn(x):
    return x*x
print(list(map(fn, [1, 2, 3, 4])))
# [1, 4, 9, 16]
print(list(map(str, [1, 2, 3, 4])))
# ['1', '2', '3', '4']

reduce

from functools import reduce
def add(x, y):
    return x + y
print(reduce(add, [1, 2, 3, 4]))
# 10

sorted()

sorted(对象，key函数制定的规则，reverse=True)，key规则，可省略，reverse=True反向排序，可省略

print(sorted([36, 5, -12, 9, -21], key=abs))
# [5, 9, -12, -21, 36]

返回函数

def calc_sum(*args):
    def sum():
        n = 0
        for i in args:
            n = n + i
        return n
    return sum
f = calc_sum(1, 2, 3, 4)
print(f)
# <function calc_sum.<locals>.sum at 0x0000018038F1E160>
print(f())
# 10

形成闭包，注意：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

lambda匿名函数

匿名函数lambda 参数:返回值 # 无return，没有名字，不用担心函数名冲突。

f = lambda x: x * x
print(f)
# <function <lambda> at 0x000001BF94BFE0D0>
print(f(5))
# 25

装饰器

def fn():
    print('fn呀')
fn()
# fn呀
print(fn.__name__) # 函数__name__属性，拿到函数的名字
# fn

# 定义一个打印日志的decorator
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
@log
def fn():
    print('fn呀')
fn()
# call fn():
# fn呀

爬取豆瓣网栗子

https://github.com/ChestnutNeko/pythonStudy/blob/main/douban.py