Python入门基础

作者: kimcastle | 来源:发表于2022-04-26 22:41 被阅读0次

学习要点：

弱语法，重原理。语法是表现，只有了解深层原理，才能灵活运用。需要深入内存，剖析原理，才能看清语法。
重思想，重设计。思想是解决问题的思路，设计是指导程序结构的过程。
学习方法：
（1）知识点必须理解（定义/作用/适用性/语法）
（2）整理笔记（三合一）
（3）当天联系独立完成
学习过程：
记：解决问题的思想 - 靠实战训练
忘：细枝末节一些东西 - 查找资料获取具体的解决

执行过程

编译型： C ，优点：执行快；缺点：开发效率低，不能跨平台
解释型：Javascript, 优点：开发效率高，能跨平台；缺点：效率低
Python: 既有编译，也有解释(字节码)，拥有上面两种优点

image.png

pycharm 快捷键

行首： Home
行尾：End
注释/取消注释： Ctrl + /
复制一行： Ctrl + d
选择多列： Alt + 鼠标点点点
上下移动行： Ctrl + Shift + 上下箭头
代码整理： Ctrl + Alt + L

数据基本运算

变量

name = "ABC" ：变量 = 表达式
语义
（1）变量名：存储真正内存地址的别名
（2）赋值号：把右边对象的地址赋值给左边的内存

image.png
多个变量赋值： b01,b02 = "apple", "banana" ,这种语法既可以用于多个变量赋值，也可以用于“交换变量”:例如 b01,b02 = b02, b01

核心数据类型（对象数据）

None 占位或解除变量地址绑定
a01 = None 变量 a01 暂时没有绑定数据地址
b01 = "苏大强"
b01= None 解除 b01 的内存地址绑定（解除与对象的关联）

image.png
整形 int (正数、0、负数)
二进制 0b 开头，后面跟 0 或 1
八进制 0o 开头，后面跟 0 ~ 7
十六进制 0x 开头, 后面跟 0~9 a ~ f A~F
浮点型 float 1.23 - 1.23
科学计算法：用于太小或太大的数 0.000000001 1e8
字符串 string "" 用双引号
数值可以用于计算，字符串只能用于显示。
del 删除变量，同时解除与变量的关联，如果可能释放对象。
del a,b 删除多个变量
c = None
当对象被标记引用数为 0 时，内存即为可回收。

image.png
id : 身份运算符，可获取变量存储对象的地址
a=1000
b=800
id(a) : 11112112
id(b) : 555455444
a is b : False
池
小整数对象池 || 文件式对象可能存储在同一地址池中
小整数对象池范围： -5 ~ 256

image.png

例如：
a = 1000 b = 1000
a is b // TRUE

数据类型转换

int() 、float()、 str()、 bool()

算术运算符

+ : 加
- ：减
* : 乘
// : 地板除 5 // 2 = 2
/ : 除 5 / 2 = 2.5
%: 余 5 % 2 = 1
% 取余用法，例如取一个3位数的个位数值： 275 % 10 = 5
** : 幂 5 ** 2 = 5 * 5

加强运算符

num += 1
num -= 1
.........

优先级

先算 - 后比较 - 再逻辑

语句

括号隐藏式换行 + 反斜杠 \ 显示换行

a = (1 
      +2
      + 3
)
b =  1 + 2 \
          +3 + 4

if elif else

image.png

if else 真值与条件表达式

真值

if 100:
    print("真值")
等同于：
if bool(100):
    print("真值")'

image.png

条件表达式
语法：变量 = 结果1 if 条件 else 结果2

image.png

while

while 语法

count = 0
 while 条件
    满足条件一直执行
    count += 1 # 计数器
    break # 打断循环
else:
    不满足条件执行一次

跳转语句 break

for

for 语法

for item  in 可迭代对象：
      item # 可迭代对象中的一个成员

while 合适有判断条件的循环
for 合适罗列可迭代对象

range 整数生成器

range(开始值，结束值，步调) range(1,10,1) : 1~9
range(10) : 0~9
可以只传结束值，结束值不包括在生成的范围内

"""
练习24：for else
如果 for 里面有 “中断” 操作，如 break、exit; 则 else 不执行；否则执行

"""
for item in range(3):
    print(item)
    break # break \ exit()
else:
    print("else 不会被执行")

函数

输入函数 input()
输出函数 print()
转换函数 int()

容器类型

字符串 Str

定义
通俗理解：双引号或单引号；字符串实际存储的是“字符”对应的“不可变”“编码值”。不可以对一个字符串变量进行多次的累加，占内存空间。“序列”，字符都是紧挨着的
编码

字节： B 、KB、MB、GB、TB （联想：字节跳动），1 字节（B） = 8 位 (bit)

image.png

2.字符：单个数字、文字与符号
3.字符集：存储字符与二进制序列对应的关系表，俗称“码表”。
4.编码：将字符转换成对应的二进制序列过程
5.解码：将二进制序列转换成对应的字符过程
6.编码方式：
（1）ASCII 码，美国，英文字母+数字，每个字符1字节
（2）GBK 码，中国，21003个汉字 + ASCII，英文 1 字节，中文 2 字节
（3）Unicode 码，万国码，国际统一编码，旧字符 2 字节，新字符 4 字节
（4）UTF-8，Unicode 的存储与传输方式，英文 1 字节，中文 3 字节

双引号和单引号在 python 语言没有区别
三引号作用：所见即所得
转义字符 \

url = "C:\nike\bibi"
#第一种转义:
url = "C:\\nike\\bibi"
#第二种转义：字符串前面加字母 r 表示原始字符串，没有转义
url = r"C:\nike\bibi"

字符串格式化
%s | %d | %f | %.2f

a = 1
b = 2
name = "请输入 %s+%s=?" % (a, b)
string = "请输入 %s" % a  #只有一个变量情况下，就不用再用括号了

容器类通用操作

部分算术运算符可以操作字符串

str_1 = "apple"
str_2 = "pear"
str_3 = str_1 + str_2 # "applepear"
str_4 *= 2 # appleapple
len = str_1 / 2 # 这种执行不了

成员操作符

str = "apple is my love"
print("apple" in str)   # True

切片，具有字符串截取+翻转功能

message = input("请输入一个字符：")
# 打印第一个字符
print(message[0])
# 打印最后一个字符
print(message[-1])
# 打印倒数第三个字符
print(message[-3])
# 打印前面两个字符
print(message[0:2])
# 倒序打印字符串
print(message[::-1])
# 如果字符串长度为奇数，则打印中间字符
if (len(message) % 2) != 0:
    print(message[len(message) // 2])

小球弹起距离计算

"""
练习30：求小球运动轨迹
（扩展）一个小球从 100m 高度落下
每次弹回原来高度一半。
计算：总共弹起来多少次(最小弹起高度0.01m)
    总共走了多少米
"""
count, height, total = 0, 100, 100  # 只做一次下落运动
while height / 2 > 0.01:  # 这里应该判断最小其他高度，while 循环体都做了上下运动
    count += 1
    height /= 2
    total += height * 2
print("总共弹起来%d次,总共走了%.2f米" % (count, total))

image.png

列表 list

列表存储的是可变的“存储变量” “序列”，因为列表存储的是“变量”，所以列表可以存储各种类型的数据。

列表内存空间图

创建空列表和默认值列表的方式

"""
练习31：list 列表
"""
# 1.创建空列表
list01 = []
list02 = list()
print(list01)
print(list02)

# 创建有默认值列表
list02 = ["apple", True, 888]
# 下面的方式不可取
# list02 = list("apple", True, 888)
print(list02)

定位：通过“索引”和“切片方式”

lists = ["apple", True, 887]
lists[1]  # True  ,直接通过索引的方式查找数据

从列表中获取一片元素组成新列表
变量 = 列表[切片]
修改一片元素
列表[切片] = 变量

lists = ["apple", True, 1888]
name = lists[:] # 从列表中获取一片元素组成新列表
lists[:] = [123]  # 修改列表元素

添加元素 append() 和插入（在指定位置插入）

lists.append("八戒")  # 在列表末尾插入元素
lists.insert(2, "牛魔王") #在索引为 2 位置插入元素

删除列表:
（1）通过元素删除, lists02.remove("apple")
（2）根据位置删除, del list02[0]

"""
练习34：在列表中[9, 25, 12, 8]，删除大于10的数
按顺序删除，会重置列表内存存储空间，
结论：删除需要倒着删

"""
lists = [9, 25, 12, 12, 12, 8]

for i in range(len(lists) - 1, -1, -1):
    if lists[i] > 10:
        del lists[i]

print(lists)

定位元素：目的，可以增删改查元素
（1）切片删除 del lists[1:3]
（2）删除列表变量 lists[1:3] = []
（3）修改列表 lists[1,3] = ["apple","pear"]
列表倒序遍历

lists = ["apple", "pear", "banana", "mango"]
# 3 , 2, 1, 0  从大倒小 index
for i in range(len(lists) -1, -1, -1)：
# -1, -2, -3, -4  
for i in range(-1, -len(lists) -1, -1):

列表内存图

（1）简单变量赋值：

简单变量赋值

（2）修改列表第一个元素
list02[0] = "无忌"

image.png

（3）直接重置第一个变量

image.png

image.png
（4）切片意味着复制多一个新列表（仅仅拷贝变量，不拷贝变量值）

image.png
（5）切片复制是“浅拷贝”

普通赋值
切片只拷贝 [:] 里面的东西，里面的东西是什么？是变量

image.png
（6）深拷贝

浅拷贝2种方式

深拷贝

深拷贝复制整个列表
（7）for 循环内存图

for 循环内存图

求出列表中的最大值

思想是：假设第一个变量是最大的，其他的变量再和第一个变量进行比较、交换。

image.png

列表与字符串对比

在 python 中字符串是不可变更的。。拼接字符串会导致产生一个新的变量存储空间，浪费内存
这时应该改用"列表"做法

"""
练习36：拼接字符串
在 python 中 字符串是不可变更的。。拼接字符串会导致产生一个新的变量存储空间，浪费内存
这时应该改用"列表"做法

练习：在屏幕中输入，遇到空字符则停止
最后打印所有输入字符串

"""
lists = []
while True:
    msg = input("请输入字符串：")
    if msg == "":
        break
    lists.append(msg)
result = "-".join(lists)
print(result)

列表推导式

"""
练习40：列表推导式
"""
list01 = [1, 2, 3, 4]
list02 = [item + 1 for item in list01]
print(list02)

list01 = [1, 5, 8, 9, 4]
list02 = [item + 2 for item in list01 if item % 2 == 0]
print(list02)

列表扩容原理 - 预留空间

列表扩容原理

image.png

元组 tuple - 按需分配

定义：由一系列变量组成的不可变序列容器，一旦创建，不可以再增加、修改、删除元素。

元组内存图

"""
练习41: 元组

"""
# 创建元组
tuple01 = (100, 200, 300)
print(tuple01)  # (100, 200, 300)
print(type(tuple01))  # tuple

# 元组与列表相互转换,只能通过关键字 tuple() \ list()
tuple02 = tuple([100, 200, 300])
print(tuple02)  # 列表转元组
lists = list((1, 2, 3))
print(lists)  # [1,2,3]  元组转列表

# 单个元组
tuple03 = (100,)

# 获取元组
tuple03 = (1, 2, 3)
print(tuple03[0])  # 1
tuple04 = tuple03[-2:]
print(tuple04)  # (2,3) 元组切片得到的还是元组，列表切片得到的还是列表，字符串切片得到的还是字符串。

tuple05 = (100, 200)
a, b = tuple05
print(a)  # 100
print(b)  # 200

a, b = "ab"
print(a)  # "a"
print(b)  # "b"

字典 dict

定义
字典存储：可变存储键值对散列
使用

# 空字典
dict01 = {}
# 有默认值
dict02 = {'xiaoming': 100, 'age': 18}
#增加、修改
dict02['sex'] = 'M'
dict02['sex'] = 'F'
#读取
for key in dict01
    print(key )
for value in dict01.values()
    print(vaule)
for key, value in dict01.items()
    print(key)
    print(vaule)
# 删除
del dict01['key']

列表变字典

lists = ["无忌", "赵敏", "周芷若"]
result = {item: len(item) for item in lists}
print(result) # {'无忌': 2, '赵敏': 2, '周芷若': 3}

集合 set

集合，可以看做没有值，只有键的 "字典"，不可重复，不可变，无序，变量组成。
集合的应用
天然的去重（例如列表转集合）和 “集合运算”

交集：返回两个集合中的相同元素 &

image.png
并集：返回两个集合中的不重复的元素 |

image.png
并集：返回两个集合中的不相同元素 ^

image.png
集合基本操作

# 创建空元素
set01 = set()  # 貌似空集合也没多大用处
set02 = {}  # 这个可不是空集合，是字典
print(set01, set02)  # set() {}

# 创建具有默认值的集合
lists = {"a", "b", "c"}
set03 = set(lists)
set04 = set("ABC")
set05 = {1, 2, 3}
print(set03, set04, set05)  # {'a', 'b', 'c'} {'B', 'A', 'C'} {1, 2, 3}

# 添加集合
print(id(set05))  # 1903291334944
set05.add(4)
print(set05)  # {1, 2, 3, 4}
print(id(set05))  # 1903291334944  说明添加修改后还是同一个集合，内存空间没有变

# 删除元素
set05.remove(1)
print(set05)  # {2, 3, 4}

# 获取所有元素
for item in set05:
    print(item)

# 数学运算
set06 = {1, 2, 3}
set07 = {2, 3, 4}
set08 = {1, 2}
print(set06 & set07)  # {2, 3}
print(set06 | set07)  # {1, 2, 3, 4}
print(set06 ^ set07)  # {1, 4}  补集，找不同的
print(set06 - set07)  # {1}     补集，找一边不同 
print(set08 < set06)  # True 子集
print(set06 > set08)  # True 超集

嵌套 for 循环练习

"""
练习55： 嵌套 for 循环练习
"""
for j in range(4):
    for i in range(6):
        print("*" if i % 2 == 0 else "#", end=" ")  # end=" " 下一行输出跟着上一行后面
    print("")  # 输出 “”, 并且下一行打印另起一行


* # * # * # 
* # * # * # 
* # * # * # 
* # * # * #

函数 def

定义：封装一定的功能，决定了函数具有通用性。做一个功能得考虑好哪些部分是公用的，封装得好，事半功倍。

def print_list(lists) # lists 这里是"形式参数"，假设这里有一个参数 lists。

lists = [1,2,3]
print_list(lists)  # 这里的 lists 是实实际际存在的，因此也称为“实际参数”

下面一段代码很真实的体现了 python “容器变量” 内存地址是如何真实运行的。相同的写法 PHP 可是做不到一样的效果

result = []
for c in range(len(list01[0])):
    line = []  # 已经声明为一个列表地址空间，后面的列表操作 line 即可影响到 result[line[]]
    result.append(line)  # 列表操作不在乎顺序，在乎内存地址关联性
    for r in range(len(list01)):
        line.append(list01[r][c])

函数内存图
在“方法区存储函数，不执行函数体”，
因为调用函数，所以开辟一块内存空间，叫“栈帧”
用于存储在函数内部定义的变量（包含参数）
执行完毕后栈帧立即释放（所创建的变量立即销毁）

image.png

def fun01(a):
    # 改变的是传入的不可变对象
    a = 100

a = 1
fun01(a)
print(a) # 1

image.png

def fun02(a):
    # 改变的是传入的可变对象
    a[0] = 100


list01 = [1]
fun02(list01)
print(list01[0])  # 100

image.png

def fun03(a):
    # 改变的是 fun03 栈帧中变量 a 的指向
    a = 100


list01 = [1]
fun03(list01)
print(list01[0])  # 1

** 特别注意函数内部修改的是“传入的可变对象” 还是修改“栈帧变量”**

总结：
可变、不可变类型在传参时的区别

不可变参数类型
数值型（整数、浮点数、复数）
布尔值
None
字符串 str
元组 tuple
固定集合 frozenset
可变参数类型
列表 list
字典 dict
集合 set

不可变类型的数据在传参时，函数内部不会改变原数据的值
可变类型的数据在传参时，函数内部可以改变原数据的值

作用域

什么是作用域？
变量作用的范围
Local 函数内部， Global 全局作用域

# 全局变量
g01 = "OK"


def fun01():
    # 局部变量：在函数内部定义的变量
    # 在函数内部可以读取全局变量，但是不能修改全局变量
    l01 = 100
    print(l01)
    # 局部作用域，可以调用全局变量
    # print(g01)  # 下边 g01 定义为全局了, 这里不能再调用了
    # 这里胡 g01 只椒函数栈帧内部定义的变量
    # g01 = "No"

    # 先定义后使用， g01 提升到外部作为全局变量
    global g01
    g01 = "No"
    print(g01)


fun01()

作用域内存图

image.png

函数的形参与实参

实参传递方式
形参传递方式

"""
练习66: 函数参数
"""


def fun01(a, b, c, d):
    print(a)
    print(b)
    print(c)
    print(d)


# 位置实参： 实参与形参的位置依次对应
fun01(1, 2, 3, 4)
# 序列实参(有序：list、str、tuple) 星序-散开
# 星号将序列散开
# 如果参数很多，可以存储在序列(字符串、列表、元组)中，
# 再通过 * 拆分，直接传入函数。
list01 = ["a", "b", "c", "d"]
fun01(*list01)
# 关键字实参：实参与形参根据名称进行对应
fun01(b=2, d=4, c=3, a=1)
# 字典实参：双星号将字典才分后按名称与形参进行对应
# 如果参数很多，可以存储在字典中，
# 再通过 ** 拆分，直接传入函数。
dict01 = {"a": 1, "c": 3, "b": 2, "d": 4}
fun01(**dict01)


# 缺省（默认）参数： 如果实参不提供，可以使用默认值
def fun02(a=0, b=0, c=0, d=0):
    print(a)
    print(b)
    print(c)
    print(d)


# 关键字实参 + 缺省形参： 调用者可以随意传递参数
fun02(b=2, c=3)


# 星号元组形参： * 将所有实参合成一个元组
# 作用：让实参个数无限
def fun03(*args):
    print(args)  # (1, 2, 3)


fun03(1, 2, 3)


# 关键字形参: 在星号元组形参后的位置必须使用关键字实参
def fun04(a, *args, b):
    print(a)  # 1
    print(args)  # (2, 3, 4)
    print(b)  # 5


fun04(1, 2, 3, 4, b=5)


# 双星号字典形参
def fun06(**kwargs):
    print(kwargs)  # {'m': 1, 'n': 2}


fun06(m=1, n=2)

# 前面任意，name 必填
def func07(*, name, **kwargs):
    print(name)  # 111
    print(kwargs)  # {'first': 888, 'a': 1}


func07(first=888, name=111, a=1)

Python入门基础

学习要点：

执行过程

pycharm 快捷键

数据基本运算

变量

核心数据类型（对象数据）

数据类型转换

算术运算符

加强运算符

优先级

语句

if else 真值与条件表达式

while

for

range 整数生成器

函数

容器类型

字符串 Str

容器类通用操作

小球弹起距离计算

列表 list

列表内存图

求出列表中的最大值

列表与字符串对比

列表推导式

列表扩容原理 - 预留空间

元组 tuple - 按需分配

字典 dict

集合 set

嵌套 for 循环练习

函数 def

作用域

函数的形参与实参

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Python入门基础

学习要点：

执行过程

pycharm 快捷键

数据基本运算

变量

核心数据类型 （对象数据）

数据类型转换

算术运算符

加强运算符

优先级

语句

if else 真值与条件表达式

while

for

range 整数生成器

函数

容器类型

字符串 Str

容器类通用操作

小球弹起距离计算

列表 list

列表内存图

求出列表中的最大值

列表与字符串对比

列表推导式

列表扩容原理 - 预留空间

元组 tuple - 按需分配

字典 dict

集合 set

嵌套 for 循环练习

函数 def

作用域

函数的形参与实参

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

核心数据类型（对象数据）