Python基础一天速成（一）

Python学习笔记，大部份内容来自尚硅谷的课程。

学而时习之。温故而知新。

一、概念介绍

Python，是一种广泛使用的高级编程语言，一种解释型语言，Python代码使用空格缩进划分代码块，主旨是用更少的代码表达想法。

Python的用途：

1. WEB应用
2. 爬虫程序
3. 科学计算
4. 自动化运维
5. 大数据（数据清洗）
6. 云计算
7. 桌面软件/游戏
8. 人工智能

快速使用：直接下载cursor，python环境配置简单，但是初学者建议关闭AI功能，否则常用记不住语法

二、基本语法

代码最好实践看结果。

一、注释
# 我是注释符号

二、输入和输出
input()函数
# input()调用后，程序会立即暂停，等待用户输入

print('he\
aaa\
aaa')

print('abc')

三.赋值
a = 'hello'
a = 1
# ps：Python是一个动态类型的语言，可以为变量赋任意类型的值，也可以任意修改变量的值


四、标识符
# 在Python中所有可以自主命名的内容都属于标识符
# 比如：变量名、函数名、类名
# 标识符规范：
#   1、标识符中可以含有字母、数字、_，但是不能使用数字开头
    a_1 = 1
    _a1 = 2
    1_a = 3
#   1_a = 4 将会报错 SyntaxError: invalid syntax

#   2、标识符不能是关键字、保留字、函数名

五、Python数值类型
# 分成三种：整数、浮点数（小数）、复数

1、在Python中所有的整数都是int类型
a = 10
# Python中的整数的大小没有限制，可以是一个无限大的整数
# c = 999999999999999999999999999999999999999999999 ** 100

进制
# d = 0123 10进制的数字不能以0开头
# 二进制 0b开头
c = 0b10
# 八进制 0o开头
c = 0o10
# 十六进制 0x开头
c = 0x10


2、浮点数（小数），在Python中所有的小数都是float类型
c = 1.23
c = 4.56

# 对浮点数进行运算时，可能会得到一个不精确的结果
c = 0.1 + 0.2 # 0.30000000000000004

六、字符串类型
1、定义
s = 'hello'
s = "hello"
# ps: 字符串必须使用引号(单双均可)，不使用不是字符串

2、不同引号用来嵌套
s = "子曰:'学而时习之！'"

3、三重引号可以换行，并且会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''

4、转义字符
# 可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
# 例子：
#   \' 表示'
#   \" 表示"
#   \t 表示制表符
#   \n 表示换行符
#   \\ 表示反斜杠
#   \uxxxx 表示Unicode编码

5、拼接字符串
a = 'abc' + 'haha' + '哈哈'

6、占位符
# %s 在字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'hello %s 你好 %s'%('tom','jack')
b = 'hello %3.5s'%'abcdefg' 
# %3.5s字符串的长度限制在3-5之间，输出hello abcde
b = 'hello %s'%123.456
# 输出hello 123.456
b = 'hello %.2f'%123.456
# 输出hello 123.45
b = 'hello %d'%123.95
# 输出hello 123


7、格式化字符串
print(f'a = {a}')

七、布尔值
# 布尔值（bool）主要用来做逻辑判断
a = True # True表示真
a = False # False表示假

# 布尔值实际上也属于整型，True就相当于1，False就相当于0
print(1 + False) # 输出为1

# None（空值）专门用来表示不存在
b = None

七、类型检查和转换
1、类型检查函数type
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello'))  # <class 'str'>
print(type(None)) # <class 'NoneType'>

2、类型转换函数 int() float() str() bool()
int() 可以用来将其他的对象转换为整型
# 规则：
#   布尔值：True -> 1   False -> 0
#   浮点数：直接取整，省略小数点后的内容
#   字符串：合法的整数字符串如'10'，可以转换为对应的数字，'10.1'则报错

float() 和 int()规则基本一致
str() 可以将对象转换为字符串

bool() 可以将对象转换为布尔值，任何对象都可以转换为布尔值

八、运算符
1、算术运算符
# + 加法运算符（如果是两个字符串之间进行加法运算，则会进行拼串操作）
# - 减法运算符
# * 乘法运算符（如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数）
# / 除法运算符，运算时结果总会返回一个浮点类型
# // 整除，只会保留计算后的整数位，总会返回一个整型
# ** 幂运算，求一个值的几次幂
# % 取模，求两个数相除的余数
2、赋值运算符
# = 可以将等号右侧的值赋值给等号左侧的变量
# +=  a += 5 相当于 a = a + 5 
# -=  a -= 5 相当于 a = a - 5 
# *=  a *= 5 相当于 a = a * 5 
# **= a **= 5 相当于 a = a ** 5 
# /=  a /= 5 相当于 a = a / 5 
# //= a //= 5 相当于 a = a // 5 
# %=  a %= 5 相当于 a = a % 5 
3、关系运算符
# 如果关系成立，返回True，否则返回False
# > 比较左侧值是否大于右侧值
# >= 比较左侧的值是否大于或等于右侧的值
# < 比较左侧值是否小于右侧值
# <= 比较左侧的值是否小于或等于右侧的值
# == 比较两个对象的值是否相等
# != 比较两个对象的值是否不相等
#   相等和不等比较的是对象的值，而不是id
# is 比较两个对象是否是同一个对象，比较的是对象的id
# is not 比较两个对象是否不是同一个对象，比较的是对象的id
4、逻辑运算符
# not 逻辑非
#   not可以对符号右侧的值进行非运算
#       
# and 逻辑与
#   and可以对符号两侧的值进行与运算
#    只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False
#    与运算是找False的
#    Python中的与运算是短路的与，如果第一个值为False，则不再看第二个值
#   
# or 逻辑或
#   or 可以对符号两侧的值进行或运算
#    或运算两个值中只要有一个True，就会返回True
#    或运算是找True的
#    Python中的或运算是短路的或，如果第一个值为True，则不再看第二个值
5、条件运算符（三元运算符）
# 语法： 语句1 if 条件表达式 else 语句2
# 执行流程：
#   条件运算符在执行时，会先对条件表达式进行求值判断
#       如果判断结果为True，则执行语句1，并返回执行结果
#       如果判断结果为False，则执行语句2，并返回执行结果

三、流程控制语法

一、if-elif-else语句
语法：
  if 条件表达式 :
      代码块
  elif 条件表达式 :
      代码块
  else :
      代码块
      
# 执行流程：
#   if-elif-else语句在执行时，会自上向下依次对条件表达式进行求值判断，
#       如果表达式的结果为True，则执行当前代码块，然后语句结束
#       如果表达式的结果为False，则继续向下判断，直到找到True为止
#       如果所有的表达式都是False，则执行else后的代码块
#   if-elif-else中只会有一个代码块会执行

age = 68

if age >= 18 and age < 30 :
    print('你已经成年了！')
elif age >= 30 and age < 60 :
    print('你已经中年了！')
elif age >= 60 :
    print('你已经退休了！')
else:
    print('未成年！')

二、循环
# 循环语句分成两种，while循环 和 for循环
while循环
语法：
  while 条件表达式 :
      代码块
  else :
      代码块
# 执行流程：
#   while语句在执行时，会先对while后的条件表达式进行求值判断，
#       如果判断结果为True，则执行循环体（代码块），
#       循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
#       直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后的代码块


循环的三个条件（表达式）
# 初始化表达式，通过初始化表达式初始化一个变量
i = 0

# 条件表达式，条件表达式用来设置循环执行的条件
while i < 10 :
     print(i)  
     i += 1 # 更新表达式，修改初始化变量的值

三、循环断点
1、break
break可以用来立即退出循环语句（包括else）

2、continue
continue可以用来跳过当次循环
# break和continue都是只对离他最近的循环起作用
3、pass
pass是用来在判断或循环语句中占位的

四、range()是一个函数，可以用来生成一个自然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2) # 生成一个这样的序列[0,2,4,6,8,10]
r = range(10,0,-1) # 生成一个这样的序列[10,9,8,7,6,5,4,3,2,1,0]
# 该函数需要三个参数
#   1.起始位置（可以省略，默认是0）
#   2.结束位置
#   3.步长（可以省略，默认是1）

练习题目：

1、求100以内所有的奇数之和

2、求1000以内所有的水仙花数（水仙花数是指一个 n 位数（n≥3 ），它的每个位上的数字的 n 次幂之和等于它本身（例如：1**3 + 5**3 + 3**3 = 153））

3、打印九九乘法表

四、序列

一、列表
my_list = [10,20,30,40,50]

1、len()函数
# 通过该函数可以获取列表的长度
print(len(my_list)) # 5

2、通过切片来获取指定的元素
# 语法：列表[起始:结束:步长] 
# 步长表示，每次获取元素的间隔，默认值是1
print(stus[0:5:3]) # 结果是：[10,40]
# 步长不能是0，但是可以是负数，表示从列表的后部向前边取元素
print(stus[::-1])
# 代表倒序这个列表，结果是：[50，40，30，20，10]

3、方法
in，not in 
len(s)
min(s)
max(s)
s.index()
s.count()

3.1、in，not in 
# in用来检查指定元素是否存在于列表中
#   如果存在，返回True，否则返回Falses
# not in用来检查指定元素是否不在列表中
#   如果不在，返回True，否则返回False

3.2、len()获取列表中的元素的个数

3.3、min() 获取列表中的最小值

3.4、max() 获取列表中的最大值

3.5、my_list.index() # 获取指定元素在列表中的第一次出现时索引
# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
print(my_list.index(30,1,3))  #2

3.6、my_list.count() # 统计指定元素在列表中出现的次数
print(my_list.count(10)) #1


3.7、append() 
# 向列表的最后添加一个元素
my_list.append('唐僧')

3.8、insert()
# 向列表的指定位置插入一个元素
# 参数：
#   1.要插入的位置
#   2.要插入的元素
my_list.insert(2,'唐僧')

3.9、extend()
# 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
stus += ['唐僧','白骨精']

3.10、clear()
# 清空序列
stus.clear()

3.11、pop()
# 根据索引删除并返回被删除的元素
result = stus.pop(2) # 删除索引为2的元素
result = stus.pop() # 删除最后一个

3.12、remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')

3.13、reverse()
# 用来反转列表
stus.reverse()

3.14、sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = [10,1,20,3,4,5,0,-2]
my_list.sort(reverse=True)
print('修改后',my_list) # 修改后 [20, 10, 5, 4, 3, 1, 0, -2]

3.15、遍历
# 通过for循环来遍历列表
# 语法：
#   for 变量 in 序列 :
#       代码块
for s in stus :
    print(s)

二、元组
# 元组是一个不可变的序列，它的操作的方式基本上和列表是一致的
# 所以你在操作元组时，就把元组当成是一个不可变的列表
# 一般当我们希望数据不改变时，就使用元组，其余情况都使用列表
my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
my_tuple = 10,20,30,40

1、元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
a,b,c,d = my_tuple
# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a , b , *c = my_tuple

2、== !=  is is not
# == != 比较的是对象的值是否相等 
# is is not 比较的是对象的id是否相等（比较两个对象是否是同一个对象）

print(a == b) # a和b的值相等，使用==会返回True
print(a is b) # a和b不是同一个对象，内存地址不同，使用is会返回False

三、字典
d = {
'name':'孙悟空' , 
'age':18 , 
'gender':'男' , 
'name':'sunwukong'
}

1、需要根据键来获取值
print(d['name'],d['age'],d['gender'])

2、方法
len()
in not in
get()
setdefault()
update()
pop()
popitem()
clear()
copy()

2.1、使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
d = dict(name='孙悟空',age=18,gender='男') 

2.2、len() 获取字典中键值对的个数
print(len(d))

2.3、in 检查字典中是否包含指定的键
not in 检查字典中是否不包含指定的键
print('hello' in d)

2.4、获取字典中的值，根据键来获取值
# 语法：d[key]
print(d['age'])

2.5、get(key[, default]) 该方法用来根据键来获取字典中的值
#   如果获取的键在字典中不存在，会返回None
#   也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值
print(d.get('hello','默认值'))

2.6、修改字典
d[key] = value # 如果key存在则覆盖，不存在则添加
d['name'] = 'sunwukong' # 修改字典的key-value
d['address'] = '花果山' # 向字典中添加key-value

2.7、setdefault(key[, default]) # 可以用来向字典中添加key-value
#   如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
#   如果key不存在，则向字典中添加这个key，并设置value
result = d.setdefault('name','猪八戒')
result = d.setdefault('hello','猪八戒')

2.8、update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)

2.9、删除，可以使用 del 来删除字典中的 key-value
del d['a']
del d['b']

2.10、popitem()
# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
#   删除之后，它会将删除的key-value作为返回值返回
#   返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
d.popitem()
result = d.popitem()

2.11、pop(key[, default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key，会抛出异常
#   如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
result = d.pop('d')
result = d.pop('z','这是默认值')

2.12、clear()用来清空字典
d.clear()

2.13、遍历字典
d = {'name':'孙悟空','age':18,'gender':'男'}

for k,v in d.items() :
    print(k , '=' , v)

通过遍历keys()来获取所有的键
for k in d.keys() :
    print(k , d[k])

# values()
# 该方法会返回一个序列，序列中保存有字典的左右的值
for v in d.values():
    print(v)

items()
# 该方法会返回字典中所有的项
# 它会返回一个序列，序列中包含有双值子序列
# 双值分别是，字典中的key和value
for k,v in d.items() :
    print(k , '=' , v)