python基础

Python基础

Author: Huang ChengLong
ShortDescription： Python基础知识 Python安装 Python注释 Python变量 基本数据类型 运算符 输入输出 流程控制

一、Python环境#

1.1 Python解释器#

即 Python 运行环境，等同于 java 的 JRE

1.1.1 下载安装#

Python官网地址 https://www.python.org/

Linux 平台选择 Source Code 下载解释器

1.1.2 python解释器使用#

（1）CMD 使用python:

（2）Git 使用python:

安装Git Bash 的时候有提示，MinTTY不支持交互操作，如Python和Node, 用winpty + program就可以运行了。

两种方法
利用 winpty 接口：winpty python
显式使用： python -i

（3）退出python

exit()

1.1.3 HelloWorld#

print("hello world")

1.2 PyCharm编译器#

PyCharm下载官网 https://www.jetbrains.com/pycharm/

二、注释#

注释的内容不会执行，一般作为重要代码的解释说明

按照 PEP 8 标准，单行注释 # 符号和注释文件要间隔一个空格；注释和代码同行要使用两个空格隔开。

# 单行注释 使用 # 号

# 这是注释1
print("1234")  # 这是注释2

===========================

# 多行注释  使用'''或"""

'''
aaa
bbb
'''

"""
bbb
ccc
"""

三、变量#

3.1 变量的基本使用#

变量来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念。变量可以通过变量名访问。

变量需要 先定义，后使用。

# 先定义 后引用
a = 100  # 定义
print(a)  # 引用

3.2 变量名命名规则#

规则:

1. 变量名只能是字母、数字和下划线的组合
2. 变量名不能以数字开头
3. 关键字不能作为变量名

风格:

原则：见名知意，不能使用拼音，尽量简短
Python 推荐使用下划线间隔

# 汤姆的年龄
age_of_tom = 18

3.3 内存管理-垃圾回收机制（GC）#

垃圾：当内存中一个变量值绑定的变量名数量为0时，称为垃圾
系统会自动回收垃圾所占据的资源，来提高资源的利用率，避免内存溢出

# 引用计数增加
x = 10  # 10的引用计数为1
y = x   # 10的引用计数为2
z = x   # 10的引用计数为3

# 引用计数减少
del x  # 变量名x与10解除绑定关系，10的引用计数由3减少1变为2
# print(x)  # 报错 ” NameError: name 'x' is not defined “ 变量名 x 未定义
del y  # 变量名y与10解除绑定关系，10的引用计数由2减少1变为1
z = 20  # z的引用指向20，此时z与10解除了绑定关系，10的引用计数为0，变为垃圾被系统回收
print(z)

循环引用:

l1 = [10]
l2 = [20]
l1.append(l2)  # l1 = [10的内存地址,l2的内存地址]
l2.append(l1)  # l2 = [20的内存地址,l1的内存地址]
# 此时l1和l2发生了循环引用，会引发内存溢出
print(l1)
print(l2)
del l1
del l2

```python

l1和l2的直接引用已经解除，但是依然被间接引用，引用计数永远不是0，但是无法访问到该内存，为了解决引用计数的致命缺陷，python解释器会标记清除，过段时间，会自动释放没有直接引用的内存。

### 3.4 变量的id和和type

id：显示变量的内存地址，内存地址不同则id不同
type：显示变量的类型

```python
name = 'tom'
print(name)
print(id(name))
print(type(name))

输出

3.5 is与==#

is： 比较左右两个变量的身份id是否相等
==： 比较左右两个变量的值是否相等

注：python解释器启动时，会自动申请内存存储常用的值，只要使用他们的id都一样，小整数池[-5,256],pycharm会扩大整数池

3.6 常量#

常量 - 即不变的量
注意： python中没有常量相关关键字，但是在程序开发中会使用到常量概念

在python中，常量变量名约定使用全大写表示

# 圆周率
PI = 3.14
# 月份总数
MONTH = 12

四、基本数据类型#

Python 是弱类型语言，定义变量是不需要类型关键字，解释器会自动识别类型

不可变类型：修改值时，id发生改变，即内存地址发生改变，不在原内存上修改值的数据类型叫不可变类型（int float str）
可变类型：修改值时，内存不会发生改变，就在原内存修改值的数据类型叫可变类型（列表 字典）

4.1 数字类型（不可变类型）#

int 整型 整数

# int
age = 18
print(type(age))

float 浮点型 小数

# float
salary = 1.3
print(type(salary))

4.2 字符类型（不可变类型）#

str 字符串 使用' '、" " 、''' '''、""" """包含的一串字符
可以使用反斜杠\转义，使单双引号可以被输出

# str
name = 'tom'
print(type(name))

字符串可以使用 + 拼接，使用 + 拼接效率很低
字符串可以使用 * ，表示该字符串拼接多少次

4.3 列表类型（可变类型）#

列表：用于记录多个值，并且可以按照索引取自定位置的值，索引从0开始，0代表第一个，
列表在 [ ] 内使用逗号分隔多个任意类型的值，一个值称为一个元素

# 列表
l = [10, 3.2, 'aaa', ['bbb', 'ccc']]
print(l[0])  # 输出 10
print(l[3][1]) # 输出 ccc

注：列表和字典中存的是内存地址

a = 10
l1 = [5,a]  # 列表中存的是10的内存地址，所以当a的引用发生变化时，l1[1]依然是10
print(l1[1])  # 输出 10
a = 20
print(l1[1])  # 输出 10

4.4 字典类型（可变类型）#

字典: 就是键值对，key对应value，其中key通常为字符串类型，key对值有描述性。 key具有唯一性，每个value有且只有一个key对应。
定义：在 { } 内使用逗号隔开多个 key:value

# 字典
d = {'a':1,'b':2}
print(d['a'])  # 输出 1

4.5 布尔类型（不可变类型）#

用于记录真假，布尔值只有 True 和 False 两种值

# 布尔值
is_true = True
is_false = False
print(type(is_true))
print(is_true == is_true)  # 输出 true
print(is_true == is_false)  # 输出 false

五、用户交互#

5.1 输入#

input关键字实现输入

input("请输入您的账号：")

使用变量接受，在python3中，input会将用户输入的所有内容都存成字符串
python2中，raw_input与python3中的input功能相同，python2中的input，要求用户必须输入一个明确的数据类型，并存成什么类型

username = input("请输入您的用户名：")
print(type(username))
age = input("请输入您的年龄")
print(type(age))

5.2 输出#

print关键字实现输入

print("tom")

格式化输出:

5.2.1 %方式（速度慢）#

• %s 按照位置与%s对应

res1 = "my name is %s ,my age is %s" %("tom","18")
print(res1)
res2 = "my name is %s" %"tom"  # 只有一个%s时，可以不用括号
print(res2)

• 字典形式传值 不受位置限制

res3 = "my name is %(name)s ,my age is %(age)s" %{"age":18,"name":"tom"}
print(res3)

%s可以接受任何类型数据，%d只能接受int整型，一般都使用%s

5.2.1 str.format()方式（速度中-推荐）#

通过python2.6引入的str.format()方式，使用此方法兼容python2和python3

• 按位置取值

res4 = "my name is {} ,my age is {}".format("tom", 18)
print(res4)

• 按索引取值

res5 = "my name is {0}{0}{0} ,my age is {1}{1}{1}".format("tom", 18)
print(res5)

• 按key=value取值

res6 = "my name is {name} ,my age is {age}".format(age=18,name="tom")
print(res6)

5.2.1 f方式（速度快）#

• 通过python3.5引入的f

x = input("your name:")
y = input("your age:")
res7 = f"my name is {x},my age is {y}"
print(res7)

六、运算符#

6.1 算术运算符（与java、c++不同的）#

6.1.1 除#

# 除
print(10 / 3)  # 保留小数
print(10 // 3)  # 只保留整数

6.1.2 次方#

# 次方
print(10 ** 3)  # 10的3次方

6.1.3 赋值#

• 交叉赋值

n = 10
m = 20
n, m = m, n  # 交换值
print("n={},m={}".format(n, m))

• 解压赋值

l = [1,2,3,4]
a,b,c,d=l
print("a={},b={},c={},d={}".format(a,b,c,d))
# *会自动把剩下的值存为列表，_在python中约定俗成是废弃的变量，不再使用
# 只去开头2个值
a,b,*_ = l
print("a={},b={}".format(a,b))
# 只去结尾2个值
*_,a,b = l
print("a={},b={}".format(a,b))

6.1.4 深浅拷贝#

浅拷贝:

浅拷贝中，可变类型依然是同一个内存地址，可变类型发生改变时，所有拷贝列表都会发生变化

# 浅拷贝和深拷贝
# 浅拷贝
list1 = [1, 2, [3, 4]]
# 使用赋值进行复制，内存地址完全一样
list2 = list1
print(id(list1))  # 输出 1817744707008
print(id(list2))  # 输出 1817744707008
# 使用copy进行拷贝，内存地址不一样，但是其中元素内存地址相同
list3 = list1.copy()
print(id(list1))  # 输出 1817744707008
print(id(list3))  # 输出 1817744608384
print(id(list1[0]))  # 输出 1817740443888
print(id(list3[0]))  # 输出 1817740443888
# 修改不可变类型元素，浅拷贝列表不受影响
list1[0] = 5
print(list1)  # 输出 [5, 2, [3, 4]]
print(list3)  # 输出 [1, 2, [3, 4]]
# 修改可变类型元素，浅拷贝列表会受影响
list1[2][0] = 6
print(list1)  # 输出 [5, 2, [6, 4]]
print(list3)  # 输出 [1, 2, [6, 4]]

深拷贝:

深拷贝中两个list的id不同，元素中的可变类型id也不同，任意列表修改其中元素，其他深拷贝列表都不受影响

# 引入深拷贝包
import copy

list4 = copy.deepcopy(list1)
# 深拷贝 两个list的id不同，元素中的可变类型id也不同，任意列表修改其中元素，其他深拷贝列表都不受影响
print(id(list1))  # 输出 2028202553344
print(id(list4))  # 输出 2028206165184
print(id(list1[2]))  # 输出 2028202553344
print(id(list4[2]))  # 输出 2028203144384

6.2 逻辑运算符#

优先级： not > and > or

6.2.1 not (逻辑非)#

not: 逻辑非 把紧跟其后的那个条件取反

print (not True)  # 输出 False
print (not False)  # 输出 True
print (not 10)  # 输出 False
print (not 0)   # 输出 True
print (not None)  # 输出 True
print (not '')  # 输出 True

6.2.1 and (逻辑与)#

and： 逻辑与 and连接左右两个条件，同真为真，一假则假

print (True and True)  # 输出 True
print (True and False)  # 输出 False
print (3 > 2 and 4 > 5)  # 输出 False

6.2.1 or (逻辑或)#

or：逻辑或 or连接左右两个添加，一真则真，同假为假

print (True or False)  # 输出 True
print (True or True)  # 输出 True
print (False or False)  # 输出 False
print (3 > 2 or 4 > 5)  # 输出 True

6.3 成员运算符#

in：判断子字符串、元素、key是否存在与字符串、列表或字典中

print("a" in "abc")  # 输出 True
print("a" in "bcd")  # 输出 False
print(1 in [1, 2, 3])  # 输出 True
print(1 in [4, 2, 3])  # 输出 False
print("a" in {"a": 1, "b": 2})  # 输出 True
print("a" in {"b": 1, "c": 2})  # 输出 False

not in: 判断子字符串、元素、key是否存在与字符串、列表或字典中，再取反 （推荐使用in）

print("a" not in "abc")  # 输出 False
print(not "a" in "abc")  # 输出 False

6.4 身份运算符#

详见3.5 is和==

• is 判断id是否相等
• == 判断值是否相等

七、流程控制#

7.1 if选择#

Python中没有switch语句，可以使用字典实现switch选择
选择语句中的语句块要缩进4个字符

语法:

if 条件:
    语句块
elif 条件:
    语句块
else:
    语句块

示例:

# if
chose1 = input("请输入数字：")
if chose1 == '1':
    print(1)

# if ... else
chose2 = input("请输入数字：")
if chose2 == '1':
    print(1)
else:
    print(2)

# if ... elif
chose3 = input("请输入数字：")
if chose3 == '1':
    print(1)
elif 2:
    print(2)

# if ... elif ... else
chose4 = input("请输入数字：")
if chose4 == '1':
    print(1)
elif chose4 == '2':
    print(2)
else:
    print(3)

7.2 循环语句#

7.2.1 while循环#

while循环：判断条件是否为True，如果为True，则循环执行代码块内容

语法:

while 条件:
    代码块

示例:

# while 输出 1-5
count = 1
while count < 6:
    print(count)
    count += 1
print("========================")

# while + break 输出 1-4
a = 0
while True:
    if a > 3:
        break
    a += 1
    print(a)
print("========================")

# while + continue 输出 3
b = 0
while True:
    b += 1
    if b < 3:
        continue
    print(b)
    break
print("========================")

7.2.2 for循环#

for循环：从可迭代对象（列表、字典、字符串、元组、集合）中循环取值
语法:

for 变量名 in 可迭代对象:
    代码块

示例:

# for循环 列表 输出 1 2 3
for x in [1, 2, 3]:
    print(x)
# for循环 字典 变量x取key  输出  k1 1 k2 2 k3 3
dic = {'k1': 1, 'k2': 2, 'k3': 3}
for x in dic:
    print(x)
    print(dic[x])

for+range 通过range控制for循环次数

for x in range(10):  # 输出 0123456789
    print(x,end='')

print()

for x in range(0,10):  # 输出 0123456789  取头不取尾
    print(x,end='')

print()


for x in range(1,9,2):  # 输出 1357  第三位2为步长，每次循环增加的值
    print(x,end='')

for+break+else (while 循环相同) 循环正常结束，执行else内容;循环非正常结束,不会执行else内容

for x in range(3):
    print(x)
    # if x == :
    #     break
else:
    print("5")