Python基础笔记(总)

1. 基础语法

print("Hello, world!")

# 单行注释

'''
多行注释1
多行注释2
多行注释3
'''

"""
多行注释1
多行注释2
多行注释3
"""

# 变量
a = 10
b = 20
c = a + b
print(c)

_a = 100
print(_a)

# 缩进是很讲究的
if a > 5:
    print("a is greater than 5")
else:
    print("a is less than or equal to 5")


# 多行强制换行，使用 \ 符号
item1 = '苹果,'
item2 = '香蕉,'
item3 = '橘子'

temp = item1 + \
      item2 + \
      item3
print(temp)

# 对于数组之类的，直接支持换行
arr = ['苹果',
       '香蕉',
       '橘子']

print(arr)

2. 数字类型

# python中数字有四种类型：整数、布尔型、浮点数和复数。

# 整数类型
# 整数类型是最简单的数字类型，它表示整数值，可以是正数、负数、0。
age = 25
print(age)  # 输出：25

# 布尔型
# 布尔型的值只有两种，True和False。
is_student = True
print(is_student)  # 输出：True

# 浮点数类型
# 浮点数类型表示小数值，可以用小数点表示。
height = 1.75
print(height)  # 输出：1.75

# 复数类型
# 复数类型表示复数值，可以用a+bj的形式表示，其中a和b是实数部分，j是虚数部分。
complex_num = 3+5j
print(complex_num)  # 输出：(3+5j)

3. 字符串类型

# 字符串类型
# Python 中单引号 ' 和双引号 " 包裹的值叫字符串

# 单引号可以包含双引号
str1='hell"o" world'
print(str1)

# 双引号可以包含单引号
str2="I'm a string"
print(str2)

# 三引号可以包含多行字符串
str3='''
This is a multi-line string.
It can have multiple lines.
'''
print(str3)

# 支持转义字符 \n 表示换行
str4='This \n is a \n string'
print(str4)

# 按字面意义拼接字符串，正常是用+连接，但是python可以不用+连接
str5='aa' 'bb' 'cc'
print(str5)

# * 重复字符串
str6='hello\n' * 3
print(str6)

# 字符串的索引
str7='hello world'
print(str7[0]) # h
print(str7[2]) # l
print(str7[-1]) # d
print(len(str7)) # 11

# 不能通过索引修改字符串
# str7[0] = 'H' 不错，不支持分配

# 可以通过调用一些方法修改它
str7 = str7.capitalize() # 转换为首字母大写
print(str7)

# 字符串切片
# 语法：字符串[开始:结束:步长]
# 开始和结束是可选参数，步长是可选参数，默认步长为1
# 开始和结束是负数，表示从字符串末尾开始算起的位置
# 步长可以为负数，表示反向切片

str8='hello world'
print(str8[0:5]) # hello
print(str8[6:]) # world
print(str8[::2]) # hlowrd
print(str8[::-1]) # dlrow olleh

# r的作用
# 前面加上r，表示原始字符串，不会对\n进行转义
print('hello\n world') 
print(r'hello\n world') # hello\n world

4. 空行

def print_hello():
    print("hello")
    
def print_world():
    print("world")

age = 20

if age >= 18:
    print_hello()
else:
    print_world()

5. 等待用户输入

age = input("请输入你的年龄：")
print("你输入的年龄是：", age)

# 可以使用逗号把多行合成一行
age = 24; name = 'Gongxian'

6.print输出

a = "x"
b = "y"

# 支持多个参数输出
print(a, b) # 输出多个参数时，可以用逗号隔开

# 换行输出
print(a)
print(b)

# 不换行输出
print(a, end=" ")
print(b)

7.猜数字游戏

target = 7 # 目标数字
max = 3    # 最大猜测次数
err = 0    # 记录错误次数

while err < max:
    num = int(input("请输入一个数字："))
    if num == target:
        print("恭喜你猜对了！", "猜了", err+1, "次")
        break
    elif num > target:
        print("猜大了，请再试一次！")
        err += 1 # 记录一次错误
    else:
        print("猜小了，请再试一次！")
        err += 1 # 记录一次错误

8.模块化管理

# 模块化管理
# 在 python 用 import 或者 from...import 来导入相应的模块。

# 整个模块导入
import sys

print("python的路径", sys.path)

# 导入模块中的函数
from sys import argv, path

print("argv: ", argv)
print("path: ", path)

9.基本数据类型

# 基本数据类型

# 连等赋值
a = b = c = 10
print(a, b, c)  # 10 10 10

# 批量赋不同值
a, b, c =  'a', True, 20
print(a, b, c)

10.标准数据类型

# 标准数据类型

# type 返回数字类型
print(type(123))  # <class 'int'>
print(type(3.14))  # <class 'float'>

# str 字符串类型
print(type('hello'))  # <class'str'>

# bool 布尔类型
print(type(True))  # <class 'bool'>

# list 列表类型
print(type([1, 2, 3]))  # <class 'list'>

# tuple 元组类型
print(type((1, 2, 3)))  # <class 'tuple'>

# set 集合类型
print(type({1, 2, 3}))  # <class'set'>

# 删除变量
age = 25
print(age)  # 25
# del age
# print(age) # age is not defined

# 数值运算
print(1+2)  # 3
print(2-1)  # 1
print(2*3)  # 6
print(3/2)  # 1.5
print(3//2)  # 1 取整除
print(3%2)  # 1 取余数
print(2**3)  # 8 乘方
# print(1 + '2') 报错，不能将字符串和数字相加

11.python有哪些假值

# python有哪些假值
# 1. 数字 0 2. False 3. 空字符串 "" 4. 空列表 [] 5. 空元组 () 6. 空字典 {} 7. None

print(0 == False) # True
print(bool(None) == False) # True
print(bool('') == False) # True
print(bool([]) == False) # True
print(bool({}) == False) # True

12.List列表

# List（列表）
# 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
# List（列表） 是 Python 中使用最频繁的数据类型。

# 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
list = [1, 'a', True, [1,2,3]]
print(list) # [1, 'a', True, [1, 2, 3]]


# 列表切片
# 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
list = ['a','b','c','d','e','f']
print(list[1:4]) # ['b', 'c', 'd']

# 相乘（重复）
list = [1,2]
print(list * 2) # [1, 2, 1, 2]

# 相加（拼接）
list1 = [1,2,3]
list2 = [4,5,6]
print(list1 + list2) # [1, 2, 3, 4, 5, 6]

# 可以赋值
list = [1,2,3]
list[1] = 'a'
print(list) # [1, 'a', 3]

# 列表的长度
list = [1,2,3]
print(len(list)) # 3

13.Tuple元组

# Tuple元组

# 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
# 元组中的元素类型也可以不相同
tuple1 = (1, 'a', True, None, [1,2])
print(tuple1)

# 访问元组中的元素
print(tuple1[0])
print(len(tuple1)) # 5

# 元祖支持切片
print(12, tuple1[1:3])

# 元祖是不可变的，不能修改元素，但它可以修改包含可变的对象，比如list列表。
# tuple1[0] = 'x' # TypeError: 'tuple' object does not support item assignment
tuple1[4][0] = 'x'
print(tuple1) # (1, 'a', True, None, ['x', 2])

# 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

# 1. 空元组 ()
empty_tuple = ()
print(empty_tuple) # ()

# 2. 只有一个元素的元组，如果元素后面没有逗号，必须在元素后面添加逗号
# tuple2 = (1) # 错误，缺少逗号
tuple2 = (1,) # 正确的写法

# 元祖也可以前套
tuple3 = ((1, 2, 3), (4, 5, 6))
print(tuple3) # ((1, 2, 3), (4, 5, 6))

# 元祖也可以相加
tuple4 = (1, 2, 3) + (4, 5, 6)
print(tuple4) # (1, 2, 3, 4, 5, 6)

# 元祖也可以重复
print( (1, 2, 3) * 2) # (1, 2, 3, 1, 2, 3)

14.Set集合

# Set（集合）
# Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。
# 在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。
set1 = {1, 2, 3, 4, 5}
print(set1)  # {1, 2, 3, 4, 5}


# 另外，也可以使用 set() 函数创建集合。
set2 = set('123') # 输出的是无序的集合
set3 = set([1,2,3])
print(set2, set3)

# 读取集合中的元素
set1 = {1, 2, 3, 4, 5}

# Set的基本操作
# 新增
# 注意：创建一个空集合必须用 set() 而不是 { }，{ }表示空字典
set2 = set()
set2.add(6)
print(set2)  # {6}

# 删除
set2.remove(6)
print(set2)  # set()

# 唯一性
set3 = {1,2,1,3,2,1}
set3.add(3)
set3.add(4)
print(set3)  # {1, 2, 3}

# 判断是否在集合中
set4 = {1, 2, 3, 4, 5}
print(1 in set4)  # True

# 判断是否为空
print(38, len(set4) == 0)


# 集合的运算

# 差集（相同的抵消，多余的不要）
set5 = {1, 2, 3, 4, 5}
set6 = {4, 5, 6, 7, 8}
set7 = set5 - set6
print(set7)  # {1, 2, 3}

# 并集
set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1 | set2
print(set3)  # {1, 2, 3, 4, 5}

# 交集
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
set3 = set1 & set2
print(set3)  # {3, 4}

# 反交集
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5}
set3 = set1 ^ set2
print(set3)  # {1, 2, 5}

15.Dictionary字典

# 字典（dictionary）是Python中另一个非常有用的内置数据类型。
# 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
# 键名不能重复，后面的覆盖前面
dist1 = {'apple': '苹果', 'banana': '香蕉' }

# 定义空字典
dist2 = {}

# 向字典中添加元素
dist2['apple'] = '苹果'
dist2['banana'] = '香蕉'
dist2[True] = '布尔值'

# 访问字典元素
print(dist2['apple'])  # 苹果
print(dist2['banana'])  # 香蕉
print(dist2[True])  # 布尔值

# 更新字典元素
dist2['apple'] = '苹果2'
print(dist2['apple'])  # 苹果2

# 遍历字典
for key in dist2:
    print(key, dist2[key])  # 1. apple 苹果2 2. banana 香蕉

# 删除字典元素
del dist2['banana']
print(dist2)  # {'apple': '苹果2'}

# 判断是否存在
print('banana' in dist2)  # False

# 基于列表和元祖快速创建字典
dist3 = dict([('apple', '苹果'), ('banana', '香蕉')])

# 推导式
dist4 = {x: x**2 for x in (2, 4, 6)}
print(dist4)  # {2: 4, 4: 16, 6: 36}

16.bytes 类型

# bytes 类型是不可变序列，它表示的是字节序列。

# 创建 bytes 类型
b = b'hello, world'
print(b)  # b'hello, world'
print(type(b))  # <class 'bytes'>

# 访问 bytes 类型元素
print(b[0])  # 104
print(b[1])  # 101

17.数据类型转换

# 数据类型转换

# 隐式类型转换

# 1. 整数和浮点数相加，结果为浮点数
print(1 + 2.0)  # 3.0

# 2. 整型和字符串类型运算结果会报错
# print('12'+ 34) # 报错，不支持

# 显式类型转换
# str、int、float

# 1. int() 强制转换为整型
print( int('3') + 5 )

# 2. str() 强制转换为字符串
print( str(3.1415926) + 'abc' )

# 3. float() 强制转换为浮点型
print( float('3.14') + 2 )

# 常用的数据类型转换函数

# 4. 进制转换
print( int('A', 16)  )

# 5. repr(x) 转换字符串
dist1 = { 'a': 1, 'b': 2 }
result = repr(dist1)
print( result, type(result) ) # "{'a': 1, 'b': 2}" <class'str'>

# 6. eval(str) 将字符串但表达式执行
print( eval('1+2') ) # 3

# 7. chr(x) 将整数转换为字符
print( chr(65) ) # 'A'
print( chr(88) ) # 'X'

# 8. ord(x) 将字符转换为整数
print( ord('A') ) # 65
print( ord('X') ) # 88

# 9. hex(x) 将整数转换为十六进制字符串
red = 255
print( hex(red) ) # 输出0xff

18.运算符

# 什么是运算符？

# 1. 算术运算符
# +加、-减、*乘、/除、//取整、%求余、**求幂

# 2. 比较运算符
# ==等于、!=不等于、>大于、<小于、>=大于等于、<=小于等于

# 3. 赋值运算符
# =、+=、-=、*=、/=、%=、**=、//=
a = 10
a += 20
print(a)  # 30

# 4. := 海象运算符(3.8版本新增)
if(a := 10) > 5:
    print(a)  # 10

# 5. 逻辑运算符
# and且、or或、not非
n = 1
m = 2
if n > 0 and m > 0:
    print("通过！")

if n > 0 or m > 0:
    print("通过！")

if not n > 0:
    print("通过！")

# 6. 成员运算符

# 6.1 in 运算符
# 用于判断元素是否在序列中，返回布尔值
print('a' in 'abc') # 字符串 True
print('d' in ['a','b','c']) # 列表 False
print('2' in (1,2,3) ) # 元祖 False
print('a' in {'a','b','c'} ) # set集合 True
print('a' in {'a':1, 'b':2}) # 字典 True

# 6.2 not in 运算符
# 用于判断元素是否不在序列中，返回布尔值
print('x' not in 'abc') # 字符串 True

# 7. 身份运算符
# is、is not
# 用于判断两个变量是否指向同一个对象，返回布尔值
a = []
b = a
c = b
print('51=>', a is c) # True


x = [1,2]
y = x
y[0] = 'a'
print(x, y) # ['a', 2] ['a', 2]

19.Python3数字

# 整个导入
# import math

# 挑选导入
from math import ceil,floor,modf,pi

# Python3 数字

age = 24
print(age)

# 释放age变量
# del age
# print(age) # 报错

# Python 数字类型转换
# 1. int(x) 将x转换为一个整数。
# 2. float(x) 将x转换到一个浮点数。

# Python 数字运算
# +、-、*、/、//、**、%

# 数学函数
# 1. abs(x) 绝对值
print( abs(2) ) # 2
print( abs(-2) ) # 2

# 2. ceil(x) 上舍入
print( ceil(10/3) ) # 4

# 3. floor(x) 下舍入
print( floor(10/3) ) # 3

# 4. round(x) 四舍五入
print( round(10/3) ) # 3

# 5. max(a,b,c) 求最大值
print( max(3,1,2) ) # 3

# 6. min(a,b,c) 求最小值
print( min(3,1,2) ) # 1

# 7. pow(x,y) 指数运算
print( pow(2, 3) ) # 8

# 8. modf(x) 返回x的整数部分与小数部分，返回元祖，第1个位置是小数部分，第2个位置是整数部分
print( modf(15.23) )

# 系统常量
print( pi )

20.随机数函数

# 整个导入
# import random
# import string

# 挑选导入
from random import choice,shuffle,uniform
from string import ascii_letters,digits,punctuation

# 随机数函数

# choice()  方法返回一个列表，元组或字符串的随机项。
# choice()是不能直接访问的，需要导入 random 模块，然后通过 random 静态对象调用该方法。

# 随机生成5-10之间的数，不包含10
range1 = range(5,10) # 5-9
# print( range, type(range) ) # 特殊的数据类型 <class 'range'>
print( choice(range1) ) # 7

# 字母、数字、特殊符号
# print('20=>', ascii_letters) # abcdefg...
# print('21=>', digits)        # 0123456789
# print('22=>', punctuation)   # !@#$%^&*()

# 包含字母、数字、特殊符号
chars = ascii_letters+digits+punctuation;
# print('26=>', chars)

# 取出指定位数
password = ''.join( choice(chars) for _ in range(6) )
print( '30=>', password )

# shuffle() 方法将序列的所有元素随机排序，注意：不返回值，会破坏list。
list1 = [1,2,3,4,5]
shuffle(list1) # 支持列表打散
print( "34=>", list1) # [4, 2, 1, 3, 5]


# uniform() 方法将随机生成下一个实数，它在 [x,y] 范围内。
print( uniform(0, 1) ) # 随机生成0-1之间的数
print( uniform(5, 10) ) # 随机生成0-1之间的数

21.Python3 字符串

import time
# Python3 字符串

# 字符串是只读的
str1 = 'abc'
# 不支持
# str1[0] = '1'

# 采用覆盖的形式
str1 = '1bc'

print(str1)

# 单引号里面可以包含双引号
# print('我是"科学家"')

# 转义就可以单引号包含单引号
print('我是\'科学家\'')

# 使用 \r 实现百分比进度
for i in range(101):
  print("\r{:3}%".format(i), end=' ')
  time.sleep(0.01)

# % 的作用
print("我叫 %s，今年 %d 岁，余额 %f" % ('小明', 24, 120.5))

# f-string
name = 'tony'
# 3.6之前的写法
print('我叫 %s' % name) # 我叫 tony

# 现在推荐
print(f'我叫{name}') # 我叫 tony

site = {
  'name': 'seecen',
  'url': 'http://www.seecen.com'
}
print(f'网站名：{site["name"]}，网址：{site["url"]}')