python简单学习笔记

1. print 输出

print(2024, '年，我要想娘')   # sep:设置打印多个内容的分隔符，默认值为空格
print(2024, '年，我要想娘', sep='', end='\n')  # end:设置print执行结束后的操作，默认值为换行

格式化输出

print('格式化字符串' % (变量1, 变量2...))

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d表示输出的整数显示6位数，不足的地方使用0补全
%f	浮点数，%.2f表示小数点后只显示两位
%%	输出%

year = 2024
month = 5
day = 9
weekday = '四'
weather = '天气晴朗'
temp = 30

print('今天是%d年%02d月%02d日星期%s，%s，温度%.1f°C' % (year, month, day, weekday, weather, temp))

2. 数据类型

整型、浮点型、布尔型、字符串
不可变的数据类型：数字、字符串、元组、布尔
可变：列表、字典、集合

# 使用type和isinstance来测试和判断类型
a = 18
print(type(a))   # <class 'int'>
print(isinstance(a, str))  # False

# 切片 变量名[起始索引:结束索引+1:步数]
# 步数默认为1，可省略不写
# 起始索引默认为0，可省略不写
# 结束索引默认为-1，可省略不写
s = 'hello'
print(s[0:1])  # h 包头不包尾
print(s[0:-1])  # hell
print(s[0:-1:2])  # hl
print(s[::2])  # hlo

# 字符串反转
print(s[-1:-6:-1])  # olleh
print(s[::-1])  # olleh

3. 运算符

逻辑运算符

运算符	描述
x and y	只有x和y的值都为True，才会返回True，否则只要其中一个值为False，就返回False
x or y	只有x、y其中一个值都为True，就返回True，否则返回False
not x	如果x为True，返回False；x为False，返回True

位运算符

# 优先级 not> and> or

# 成员运算符
print('a' in 'abc')  # True
print('a' not in 'abc')  # False

# 位运算符
# 001 011
print(1 & 3)  # 1
print(1 | 3)  # 3
print(1 ^ 3)  # 2
print(~1)  # -2
print(1 << 2)  # 4
print(1 >> 2)  # 0

4. 列表List

# 列表的创建
list1 = []
list2 = [1, 2, 3, 'fg']
list3 = list()
list4 = list('12345')  # str -> list
print(list1, list2, list3, list4)  # [] [1, 2, 3] [] ['1', '2', '3', '4', '5']

# 列表的操作
print(list4[1:4:2])  # ['2', '4']
print(list2 + list4)  # [1, 2, 3, 'fg', '1', '2', '3', '4', '5']
print(len(list4))  # 5
print(max(list4))  # 5

del list2  # 删除列表

# 列表的遍历
for i in list4:
    print(i)
# 带索引打印出来
for i, j in enumerate(list4):
    print(i, j)
for i in range(len(list4)):
    print(i, list4[i])

# 列表的常用方法
l1 = []
# append 在列表末尾添加元素
l1.append('666')  # ['666']
# extend 添加的是一个列表
l1.extend('鸡鸡')  # ['666', '鸡', '鸡']
# 插入元素
l1.insert(1, 'fg')  # ['666', 'fg', '鸡', '鸡']
# 删除元素
l1.pop(2)  # ['666', 'fg', '鸡']
# remove 删除某个元素(如果有多个相同元素，只删除第一个)
l1.remove('鸡')  # ['666', 'fg']
# 清空列表
l1.clear()  # []

5. 元组Tuple

元组的元素不能修改，用 () 定义

tuple1 = (1, 2, 3, True, 'hello')
print(tuple1)

tuple2 = (1,)  # 只有一个元素时，要加逗号
print(type(tuple2))  # <class 'tuple'>

tuple3 = ()
tuple4 = tuple('hello')  # str --> hello
print(tuple4)  # ('h', 'e', 'l', 'l', 'o')
tuple5 = tuple([1, 2, 3, 4])  # list --> tuple
print(tuple5)  # (1, 2, 3, 4)

list1 = list(tuple5)  # tuple --> list
print(list1)  # [1, 2, 3, 4]

str1 = str(tuple5)  # tuple --> str
print(str1)  # '(1, 2, 3, 4)'
print(str1[0])  # '('

i = tuple1.index(2)
print(i)

6. 字符串

s1 = 'hello world'
print(s1.strip())  # 去除字符串前后的空格
print(s1.split(' '))  # ['hello', 'world']
print(s1.find('h'))  # 返回的是索引0
print('#'.join(['111', '222']))  # 111#222
print(s1.replace('o', '*'))   # hello w*rld

7. 字典dict

列表是有序的对象集合，字典是无序的对象集合。

dic = {
    'name': 'fg',
    'age': 18,
}
# 添加键
dic['gender'] = '男'
print(dic)

# 修改键
dic['age'] = 22
print(dic)

# 删除键
del dic['age']
print(dic)

# 遍历字典
for key in dic:
    print(key, dic[key])
print(dic.items())  # dict_items([('name', 'fg'), ('gender', '男')])

# 常用方法
dic.pop('name')  # 删除键name
dic2 = dic.copy()  # 复制
print(dic2.get('gender'))  # 男
dic2.update({'name': 'fg', 'age': 18})
print(dic2)  # {'gender': '男', 'name': 'fg', 'age': 18}
dic2.clear()
print(dic2)  # {}

8. 集合set

不允许有重复元素，是一种无序且重复元素的数据结构

s = {1, 2, 3, 4}
print(type(s))  # <class 'set'>

# 常用方法
s.remove(3)  # {1, 2, 4}
s.update({5, 6, 7})  # {1, 2, 4, 5, 6, 7}
s.add(8)  # {1, 2, 4, 5, 6, 7, 8}

s1 = {1, 2, 5, 6}
s2 = {5, 6, 7}
# 交集
print(s1 & s2)  # {5, 6}
# 并集
print(s1 | s2)  # {1, 2, 5, 6, 7}

# 列表去重
score = [10, 20, 30, 40, 10, 20, 30]
s = set(score)
print(list(s))  # [40, 10, 20, 30]
for i in s:
    n = score.count(i)
    print(f'{i}出现了{n}次')

9. 函数

可变参数

# 可变参数  接收元组
def func(*args):
    print(args)


func(1, 2, 3)  # (1, 2, 3)


# 可变参数  接收字典
def func1(**kwargs):
    print(kwargs)


func1(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}

变量作用域

# 变量作用域
num = 1
list1 = [1, 2, 3]  # 可变数据类型 不用global全局变量声明也能修改


def func2():
    num = 2
    list1[1] = 3
    print(num)


def func3():
    global num  # 不可变的数据类型要全局变量声明
    num = 2
    print(num)


func2()  # 2
print(num)  # 1
print(list1)  # [1, 3, 3]

func3()  # 2
print(num)  # 2

匿名函数

func4 = lambda x: x + 1
print(func4(1))  # 2

map()函数

在python中，map()函数是一个高阶函数，它接收一个函数和一个可迭代对象（如列表）作为参数，将函数应用于可迭代对象的每个元素，并返回一个新的迭代器。map()函数通常用于处理嵌套的列表或元组。

# map()函数
list2 = [1, 2, 3, 4, 5]
res = map(lambda x: x**2, list2)
print(list(res))  # [1, 4, 9, 16, 25]

reduce()函数

在python中，reduce()函数是一个高阶函数，它接收一个函数和一个可迭代对象（如列表）作为参数，将函数应用于可迭代对象的每个元素，从左到右遍历，将前两个元素的结果与下一个元素作为参数传递给函数，直到遍历完整个可迭代对象。reduce()函数通常用于处理嵌套的列表或元组。

from functools import reduce

list2 = [1, 2, 3, 4, 5]
res = reduce(lambda x, y: x + y, list2)
print(res)  # 15

filter()函数

在python中，filter()函数是一个高阶函数，它接收一个函数和一个可迭代对象（如列表）作为参数，将函数应用于可迭代对象的每个元素，根据函数返回值是True还是False，决定是否保留该元素。最后，filter()函数返回一个新的迭代器。

list2 = [1, 2, 3, 4, 5]
res = filter(lambda x: x > 3, list2)
print(list(res))  # [4, 5]

10. 递归

一个函数调用自身称为递归调用
一个会调用自身的函数称为递归函数

# 有n阶楼梯，每次上1阶或2阶，共有多少种上法？
def climb_stairs(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return climb_stairs(n - 1) + climb_stairs(n - 2)

for i in range(1, 11):
    print(f'爬{i}阶楼梯的方法有：{climb_stairs(i)}种')

11. 文件

import os

# 获取文件路径
file_path = os.getcwd()
path = file_path + '/测试文件/test.txt'
print(path)

# 打开文件
# f = open('测试文件/test.txt', encoding='utf-8')
f = open(path, mode='r', encoding='utf-8')

# 读取文件内容
context = f.read()
print(context)

# 关闭文件
f.close()

import csv

with open('测试文件/data.csv', mode='r', encoding='utf-8') as f:
    content = csv.reader(f)
    # 获取表头
    head = next(content)
    print('%s  %s  %s  %s' % (head[0], head[1], head[2], head[3]))
    # 获取内容
    for row in content:
        print('%s  %s  %s  %s' % (row[0], row[1], row[2], row[3]))