Python基础教程 - 从入门到精通

博主： silverwq
发布时间：2022 年 12 月 25 日
1729 次浏览
暂无评论
12723字数
分类： Python

基础知识

安装完成后可以使用 python 命令，终端输入 python 后，可以输入代码，ctrl+z 然后回车可以退出，或 exit()
文件名和文件夹名称最好使用小写字母，使用下划线代替空格，这是规范
文件末尾为 .py

变量

变量的基本使用如下，没有关键字，也没有 php 的 $ ：

message = "hello world"  
print(message)

关于变量的命名规则规范，和其他语言一样，略过。

可以一下子个多个变量赋值，左右数量要对上：

x,y = 1,2  
print(x) # 1  
print(y) # 2

Python 中没有常量类型，会使用全大写来指出应将某个变量视为常量，其值应始终不变

MAX_CONNECTION_AMOUNT = 100  
print(MAX_CONNECTION_AMOUNT)

字符串

用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。好处是：这种灵活性让你能够在字符串中包含引号和撇号。

message1 = 'hello world "~" '  
message2 = "hello world '~' "  
print(message1,message2)

可以调用字符串变量的方法，对字符串进行操作

message1 = 'hello world'  
print(message1.title()) # 首字母大写  
print(message1.upper())  
print(message1.lower())

字符串中使用变量，可在前引号前加上字母 f，是字母 format 的缩写，让 python 来格式化替换，然后再在花括号里输入变量名称。这种字符串叫做 f 字符串

first_name = "张"
last_name = "三"
full_name = f"{first_name}{last_name}"
print(full_name)

# 3.6 版本以前需要这样替换
# 将按顺序将这些花括号替换为圆括号内列出的变量的值
first_name = "张"  
last_name = "三"  
full_name = "{}{}".format(first_name,last_name)  
print(full_name)

# 也可以指定变量名称
err =  "{item_type}_{item_id}".format(item_type=item_type, item_id=item_id)

# 可以使用格式化语法
str = '"虚拟金额"不在服务端指定金额内：%d' % (item["fake_amount"])
str = '"虚拟金额"不在服务端指定金额内：%d' % fake_amount

使用制表符或换行符来添加空白，单引号和双引号没有区别，不像 php

languages = '编程语言有：\n\t1.PHP\n\t2.Goland'
print(languages)

删除空白字符串，制表符、空格啥的都算空白字符。

languages = ' 最喜欢的编程语言是：PHP! '
print(languages.lstrip()) # 删除左边的空白字符
print(languages.rstrip()) # 删除右边的空白字符

数

简单的加减乘除, 求模，整数和浮点数都可以

# 整数运算
print(1+1)
print(1-2)
print(1*2)
print(1/2)
print(1%2)
print(2 + 3*4) # 14
print((2 + 3) * 4) # 20

# 浮点数
print(0.1 + 0.1)

使用两个乘号表示乘方运算

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

Python 将所有带小数点的数称为浮点数，将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除

print(4/2) # 2.0

在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数：

print(1.0 + 2) # 3.0

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读

money = 1_000 # 1千
print(money) # 1000

注释

使用 # 注释

# 输出hello
print("hellow")

列表介绍

Python 使用两个方扩号表示列表，类似 php 的数组

languages = ["PHP","Goland","Python"]  
print(languages)

使用 len () 方法来获取长度

languages = ["PHP","Goland","Python","Java"]
print(len(languages)) # 4```

访问

访问列表元素，从 0 开始

languages = ["PHP","Goland","Python"]  
print(languages[0])

访问最后一个列表元素提供了一种特殊语法。通过将索引指定为 -1，可让 Python 返回最后一个列表元素

languages = ["PHP","Goland","Python"]
print(languages[-1]) # python
print(languages[-2]) # goland

可以像使用其他变量一样使用列表中的各个值

languages = ["PHP","Goland","Python"]
print(languages[-1].upper()) # python
print(f"最后一个语言是{languages[-1]}") # python

访问不存在的 index，会报错

languages = ["PHP","Goland","Python","Java"]  
print(languages[5]) # 4

增删改

修改列表中的元素，这个和 php 的数组修改方式是一样的

languages = ["PHP","Goland","Python"]
languages[0] = "php"
print(languages) # ['php', 'Goland', 'Python']

使用 append 方法向末尾添加

languages = ["PHP","Goland","Python"]  
languages.append("Java")  
print(languages) # ['PHP', 'Goland', 'Python', 'Java']

还可以在中间插入

languages = ["PHP","Goland","Python"]
languages.insert(1,"Java")
print(languages) # ['PHP', 'Java', 'Goland', 'Python']

使用 del 语句删除元素

languages = ["PHP","Goland","Python","Java"]
del languages[3]
print(languages) # ['PHP', 'Goland', 'Python']

也可以使用 pop 来弹出，需要注意的是，可以指定弹出哪个位置的元素

languages = ["PHP","Goland","Python","Java"]
print(languages.pop()) # java
print(languages.pop(1)) # Goland
print(languages) # ['PHP', 'Python']

根据值来删除，方法 remove () 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来确保将每个值都删除。

languages = ["PHP","Goland","Python","Java"]
languages.remove('Java')
print(languages) # ['PHP', 'Goland', 'Python']

排序

方法 sort ()，永久性地修改列表元素的排列顺序

languages = ["PHP","Goland","Python","Java"]
languages.sort()
print(languages) # 正序 ['Goland', 'Java', 'PHP', 'Python']
languages.sort(reverse=True)
print(languages) # 反序 ['Python', 'PHP', 'Java', 'Goland']

使用 sorted () 方法，临时排序并且返回

languages = ["PHP","Goland","Python","Java"]  
print(sorted(languages)) # 正序 ['Goland', 'Java', 'PHP', 'Python']print(languages) # ['PHP', 'Goland', 'Python', 'Java']

列表元素顺序反转，不是降序排序

languages = ["PHP","Goland","Python","Java"]
languages.reverse()
print(languages) # ['Java', 'Python', 'Goland', 'PHP']

遍历

使用 for…in…: 来遍历，缩进里面的代表是循环体里的

languages = ["PHP","Goland","Python","Java"]
for language in languages:
    print(language) # 缩进，在循环体里
print("finish") # 不在循环体里

对不能缩进的代码进行缩进，会报错

languages = ["PHP","Goland","Python","Java"]
    print(languages) # 这个不能缩进

便利的时候，带有 index

for index, item in enumerate(activity_dict['active_cfg_list'], start=1):
    print(index)

可以快速的转为字典

order_dict = {order['order_id']: order for order in data['order_info_list']}

数值列表

使用 range 创建数值列表，类似 php 里的迭代器，可以用于遍历

for ele in range(1,5):
    print(ele)

对数字列表执行简单的统计计算

numbers = [1,2,3,4,5,6]
print(min(numbers))
print(max(numbers))
print(sum(numbers))

列表解析，快速生成列表

numbers = [value**2 for value in range(1,3)]
print(numbers) # [1, 4]

切片

还可以处理列表的部分元素，Python 称之为切片。左包含，右不包含

languages = ["PHP","Goland","Python","Java"]  
print(languages[0:2]) # ['PHP', 'Goland']  
print(languages[:2]) # ['PHP', 'Goland']  
print(languages[2:]) # ['Python', 'Java']  
print(languages[:]) # ['PHP', 'Goland', 'Python', 'Java']  
print(languages) # ['PHP', 'Goland', 'Python', 'Java']

切片也可以遍历

languages = ["PHP","Goland","Python","Java"]
for ele in languages[:2]:  
    print(ele)

如果要复制一份独立的列表，可以进行切片后复制，直接复制是引用

languages = ["PHP","Goland","Python","Java"]  
myL = languages[:]  
languages.pop()  
print(myL) # ["PHP","Goland","Python","Java"]

拼接字符串

用字符连接

award_name_str = ",".join(award_name_list)

元组

Python 将不能修改的值称为不可变的，而不可变的列表被称为元组。不可修改!!

languages = ("PHP","Goland","Python","Java")  
print(languages[1])  
print(languages) # ('PHP', 'Goland', 'Python', 'Java')

可以被遍历。

格式

要提出 Python 语言修改建议，需要编写 Python 改进提案（Python Enhancement Proposal，PEP）。PEP 8 是最古老的 PEP 之一，向 Python 程序员提供了代码格式设置指南。

缩进：PEP 8 建议每级缩进都使用四个空格。而不是 tab 缩进。
PEP 8 还建议注释的行长不应超过 72 字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符
要将程序的不同部分分开，可使用空行
函数给形参指定默认值的时候，= 左右不能有空格，好像有空格也不会报错就是了

流程

条件测试

相等比较 ==，区分大小写，如果不想区分的话，可以转为大写后再比较，注意，字符串的 1 和数值的 1 是不相等的
不相等比较 !=，都一样略过
数值比较，>,>=,<,<=，这个都一样，略过

是否在列表中，使用关键字 in。

languages = ("PHP","Goland","Python","Java")  
if "PHP" in languages:  
    print("zai")

是否不在列表中，使用关键字 in。

languages = ("PHP","Goland","Python","Java")  
if "js" not in languages:  
    print("不在")

布尔表达式，字符串和布尔值比较的话，不管是 true 还是 false，都不会进去，数值类型可以比较

if "1.0" == True:  
    print("不能比较")

多条件检查可以用：and、or

If

每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式称为条件测试。也要缩进。并且 elif 和 else 是可以省略的

# if
name = '张三'  
if name == "张三":  
    print("是张三")

# if else
name = '张三'  
if name == "张三":  
    print("是张三")  
else:  
    print("不是张三")

# if elif else
name = '李四'  
if name == "张三":  
    print("是张三")  
elif name == "李四":  
    print("是李四")  
elif name == "王五":  
    print("是王五")
else:  
    print("不是张三和李四和王五")

判断列表是否有值，不能和 true 和 false 比较，Python 将在列表至少包含一个元素时返回 True，并在列表为空时返回 False。

lan = [1]  
if lan:  
    print("aa")

三目运算

server_id = int(params.get('server_id')) if params.get('server_id') else None

not in list 判断

# not in list
if item["fake_amount"] not in amount_list:

is null 判断

# 相当于is_null(fake_amount)
fake_amount is None

是否在数组或者集合中

# check_config_ids = [1,2]
return config_id in set(check_config_ids)

While

和其他语言一样，也可以使用 break 退出循环，使用 continue 跳过循环

current = 5  
while current >= 0 :  
    print(current)  
    current -= 1

Python 好像没有 for 循环，只有 for in 循环。

字典

在 Python 中，字典是一系列键值对。每个键都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。

person = {'name': 'zhangSang', 'age': 30}
print(person['name']) # key不存在也会报错
print(person.get("age",31)) # key不存在的话不会报错

添加和修改元素，删除元素

person = {'name': 'zhangSang', 'age': 30}
person["name"] = "lisi" # 修改
person["sexy"] = "男" # 添加
del person['age'] # 删除
print(person)

可以遍历

# 遍历key-value
person = {'name': 'zhangSang', 'age': 30}  
for key,value in person.items():  
    print(key,"=>",value)

# 遍历key
person = {'name': 'zhangSang', 'age': 30}  
for key in person.keys():  
    print(key)

# 遍历值
person = {'name': 'zhangSang', 'age': 30}  
for value in person.values():  
    print(value)

需要注意的是，如果没 key，则是集合

personSet = { 'zhangSang', 30}  
for value in personSet:  
    print(value)

可以在字典中存储字典，也可以在字典中存储列表，具体忽略。

输入

可以使用 input 来获取输入

message = input("请输入：")  
print(message)

因为输入的值，单做字符串，不可以和数值进行比较大小，否则会报错，所以要用 int 函数转换下

age = input("请输入年龄：")  
age = int(age)  
if age >= 12 : # 需要转换下，不然这会报错  
    print(age)

函数

简单的定义如下

def hello_world():  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print("hellow world")  

hello_world()

加上参数

def hello_world(name):  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print("hellow world",name)  

hello_world("张三")

还有一些知识点：

传入参数可以位置实参，关键字实参。
形参的默认值和 php 都一样
返回也是和 php 一样。也可以返回多个值，接收变量也要对应
如果有要传入可变参数的话可以在形参前面加 *，例如 def hello_world(*param):，会创建一个空元组，类似 php 的 function hello_world(…param)

如果有要传入可变参数的话可以在形参前面加 **，可以传入键值对，存在字典中

def hello_world(**p):  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print(p)  

hello_world(a=1,b=2) # {'a': 1, 'b': 2}

参数后面的冒号是参数类型建议符，用来提供给程序员建议传入的实参类型，即使去掉也不会有任何影响。结尾的箭头 ->代表着 函数返回值建议符，用来提供函数返回值的数据类型。

class Solution:
    def search(self, nums: List[int], target: int) -> int:

模块

模块是扩展名为 .py 的文件，包含要导入到程序中的代码。通过将 函数和类 等存储在称为模块的独立文件中，再将模块导入到主程序中使用，可以使得代码更加清晰。模块名称就是文件名称。

然后直接导入后就可以使用，导入的时候，首先会从当前目录查找该模块的文件名称，然后将它复制过来执行。导入方式有：

# 导入整个模块内容
import hello
# 导入模块中的函数、类、变量啥的
from hello import hello_world
# 换行的话，要用\
from hello import hello_world1,hello_world2,\
hello_wordl3
from hello import * # 导入所有函数

# as 起别名
from hello import hello_world as hw
import hello as hl

注意：导入就是将代码复制过来，导入的时候会执行模块文件里的代码。但是在一个模块来重复导入其他模块，只会执行一次。

包

目录中有 __init__.py 的就是包，所以可以说包就是目录，一个包里有很多个模块，模块就是一个文件。可以用 import 导入包。

类

简单的声明如下：

class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  

    def get_name(self):  
        print(self.name)  

p = Person("张三")  
p.get_name()  
print(p.name,p.age)

首字母大写的代表是类，调用的时候，表示实例化，区分函数调用，不过这只是规范而已。

构造函数

这个是构造函数，实例化的时候会自动调用。有三个参数，形参 self 必不可少，而且必须位于其他形参的前面，实例化的时候将自动传入实参 self。每个与实例相关联的方法调用都自动传递实参 self，它是一个指向实例本身的引用。

继承

简单的使用如下，继承 Person 类

class BlackPerson(Person):  
    def __init__(self, name, age):  
        super().__init__(name, age)  
        self.skin = "黑色皮肤" # 子类特有的属性  

    def get_skin(self):  
        print(self.skin)  

p = BlackPerson("Jack张", 18)  
p.get_addr()  
p.get_skin()

super () 是一个特殊函数，让你能够调用父类的方法。

文件

读取

简单的语法如下所示，读取整个文件：

with open("text.txt") as file_object:  
    contents = file_object.read()  

print(contents.rstrip()) # 好像read的末尾多了一个空行

关键字 with 在不再需要访问文件后将其关闭，因为我们调用了 open ()，但没有调用 close ()，with 会自动在合适的时候关闭它。

还可以逐行读取

with open("text.txt") as file_object:  
    for line in file_object:  
        print(line)

还可以获取列表的行内容：

with open("text.txt") as file_object:  
    lines = file_object.readlines()  

print(lines)

还可以通过文件里解析 json 的格式内容

with open("text.txt") as file_object:  
    contents = json.load(file_object)  

print(contents)

写入

简单的使用如下，可以选择模式，是追加还是覆盖

with open("text.txt",'w') as file_object:  
    lines = file_object.write("haha")

还可以写入 json 数据

person = {  
    "name":"张三",  
    "age":20,  
}  
with open("text.txt",'w') as file_object:  
    json.dump(person,file_object)

异常

简单是使用如下所示：

try:  
    answer = 5/1  
except ZeroDivisionError:  
    print("除数不能为0")  
else:  
    print(answer)

如果没有异常就会执行 else 分支。

如果捕获异常后什么都不要做的话，可以使用 pass。pass 语句还充当了占位符，提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。

try:  
    answer = 5/0  
except ZeroDivisionError:  
    pass  
else:  
    print(answer)

单元测试

简单使用

class TestHelloCase(unittest.TestCase):  # 要继承这个类
    def test_hello_world(self):  
        tmp = hello.hello_world() # 这个返回值进行比较  
        self.assertEqual(tmp,"hello word")  # 断言


if __name__ == '__main__':  # 防止导入的时候被执行
    unittest.main()

如果测试的是类，经常需要在方法里重复实例化，如果想要只实例化一次，可以使用 setup 方法存起来。

__name__ 是用来标识模块名字的一个系统变量。这里分两种情况：

第一种情况指的是当前运行的模块，那么当前模块 __name__ 的值就为 "main"；
第二种情况指的是该模块是使用 import 导入的模块，那么这个被导入模块的 __name__ 变量的值为该模块的文件名（去掉. py）

最后修改：2023 年 12 月 30 日

如果觉得我的文章对你有用，请随意赞赏

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

评论 *

私密评论

名称 *

🎲

邮箱 *

地址

Python基础教程 - 从入门到精通

silverwq • 2022 年 12 月 25 日

<h2>基础知识</h2>
<ol>
<li>安装完成后可以使用 python 命令，终端输入 python 后，可以输入代码，ctrl+z 然后回车可以退出，或 <code>exit()</code></li>
<li>文件名和文件夹名称最好使用小写字母，使用下划线代替空格，这是规范</li>
<li>文件末尾为 <code>.py</code></li>
</ol>
<h3>变量</h3>
<p>变量的基本使用如下，没有关键字，也没有 php 的 <code>$</code> ：</p>
<pre><code class="language-python">message = "hello world"  
print(message)</code></pre>
<p>关于变量的命名规则规范，和其他语言一样，略过。</p>
<p>可以一下子个多个变量赋值，左右数量要对上：</p>
<pre><code class="language-python">x,y = 1,2  
print(x) # 1  
print(y) # 2</code></pre>
<p>Python 中没有常量类型，会使用全大写来指出应将某个变量视为常量，其值应始终不变</p>
<pre><code class="language-python">MAX_CONNECTION_AMOUNT = 100  
print(MAX_CONNECTION_AMOUNT)</code></pre>
<h3>字符串</h3>
<p>用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。好处是：这种灵活性让你能够在字符串中包含引号和撇号。</p>
<pre><code class="language-python">message1 = 'hello world "~" '  
message2 = "hello world '~' "  
print(message1,message2)</code></pre>
<p>可以调用字符串变量的方法，对字符串进行操作</p>
<pre><code class="language-python">message1 = 'hello world'  
print(message1.title()) # 首字母大写  
print(message1.upper())  
print(message1.lower())</code></pre>
<p>字符串中使用变量，可在前引号前加上字母 f，是字母 format 的缩写，让 python 来格式化替换，然后再在花括号里输入变量名称。这种字符串叫做 <strong>f 字符串</strong></p>
<pre><code class="language-python">first_name = "张"
last_name = "三"
full_name = f"{first_name}{last_name}"
print(full_name)

# 3.6 版本以前需要这样替换
# 将按顺序将这些花括号替换为圆括号内列出的变量的值
first_name = "张"  
last_name = "三"  
full_name = "{}{}".format(first_name,last_name)  
print(full_name)

# 也可以指定变量名称
err =  "{item_type}_{item_id}".format(item_type=item_type, item_id=item_id)

# 可以使用格式化语法
str = '"虚拟金额"不在服务端指定金额内：%d' % (item["fake_amount"])
str = '"虚拟金额"不在服务端指定金额内：%d' % fake_amount</code></pre>
<p>使用制表符或换行符来添加空白，单引号和双引号没有区别，不像 php</p>
<pre><code class="language-python">languages = '编程语言有：\n\t1.PHP\n\t2.Goland'
print(languages)</code></pre>
<p>删除空白字符串，制表符、空格啥的都算空白字符。</p>
<pre><code class="language-python">languages = ' 最喜欢的编程语言是：PHP! '
print(languages.lstrip()) # 删除左边的空白字符
print(languages.rstrip()) # 删除右边的空白字符</code></pre>
<h3>数</h3>
<p>简单的加减乘除, 求模，整数和浮点数都可以</p>
<pre><code class="language-python"># 整数运算
print(1+1)
print(1-2)
print(1*2)
print(1/2)
print(1%2)
print(2 + 3*4) # 14
print((2 + 3) * 4) # 20

# 浮点数
print(0.1 + 0.1)</code></pre>
<p>使用两个乘号表示乘方运算</p>
<pre><code class="language-python">print(2 ** 2) # 2的2次方 
print(3 ** 2) # 3的2次方</code></pre>
<p>Python 将所有带小数点的数称为浮点数，将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除</p>
<pre><code class="language-python">print(4/2) # 2.0</code></pre>
<p>在其他任何运算中，如果一个操作数是整数，另一个操作数是浮点数，结果也总是浮点数：</p>
<pre><code class="language-python">print(1.0 + 2) # 3.0</code></pre>
<p>书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读</p>
<pre><code class="language-python">money = 1_000 # 1千
print(money) # 1000</code></pre>
<h3>注释</h3>
<p>使用 <code>#</code> 注释</p>
<pre><code class="language-python"># 输出hello
print("hellow")</code></pre>
<h2>列表介绍</h2>
<p>Python 使用两个方扩号表示列表，类似 php 的数组</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]  
print(languages)</code></pre>
<p>使用 len () 方法来获取长度</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
print(len(languages)) # 4```</code></pre>
<h3>访问</h3>
<p>访问列表元素，从 0 开始</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]  
print(languages[0])</code></pre>
<p>访问最后一个列表元素提供了一种特殊语法。通过将索引指定为 -1，可让 Python 返回最后一个列表元素</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]
print(languages[-1]) # python
print(languages[-2]) # goland</code></pre>
<p>可以像使用其他变量一样使用列表中的各个值</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]
print(languages[-1].upper()) # python
print(f"最后一个语言是{languages[-1]}") # python</code></pre>
<p>访问不存在的 index，会报错</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]  
print(languages[5]) # 4</code></pre>
<h3>增删改</h3>
<p>修改列表中的元素，这个和 php 的数组修改方式是一样的</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]
languages[0] = "php"
print(languages) # ['php', 'Goland', 'Python']</code></pre>
<p>使用 append 方法向末尾添加</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]  
languages.append("Java")  
print(languages) # ['PHP', 'Goland', 'Python', 'Java']</code></pre>
<p>还可以在中间插入</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python"]
languages.insert(1,"Java")
print(languages) # ['PHP', 'Java', 'Goland', 'Python']</code></pre>
<p>使用 del 语句删除元素</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
del languages[3]
print(languages) # ['PHP', 'Goland', 'Python']</code></pre>
<p>也可以使用 pop 来弹出，需要注意的是，可以指定弹出哪个位置的元素</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
print(languages.pop()) # java
print(languages.pop(1)) # Goland
print(languages) # ['PHP', 'Python']</code></pre>
<p>根据值来删除，方法 remove () 只删除第一个指定的值。如果要删除的值可能在列表中出现多次，就需要使用循环来确保将每个值都删除。</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
languages.remove('Java')
print(languages) # ['PHP', 'Goland', 'Python']</code></pre>
<h3>排序</h3>
<p>方法 sort ()，永久性地修改列表元素的排列顺序</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
languages.sort()
print(languages) # 正序 ['Goland', 'Java', 'PHP', 'Python']
languages.sort(reverse=True)
print(languages) # 反序 ['Python', 'PHP', 'Java', 'Goland']</code></pre>
<p>使用 sorted () 方法，临时排序并且返回</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]  
print(sorted(languages)) # 正序 ['Goland', 'Java', 'PHP', 'Python']print(languages) # ['PHP', 'Goland', 'Python', 'Java']</code></pre>
<p>列表元素顺序反转，不是降序排序</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
languages.reverse()
print(languages) # ['Java', 'Python', 'Goland', 'PHP']</code></pre>
<h3>遍历</h3>
<p>使用 <code>for…in…:</code> 来遍历，缩进里面的代表是循环体里的</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
for language in languages:
    print(language) # 缩进，在循环体里
print("finish") # 不在循环体里</code></pre>
<p>对不能缩进的代码进行缩进，会报错</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
    print(languages) # 这个不能缩进</code></pre>
<p>便利的时候，带有 index</p>
<pre><code class="language-python">for index, item in enumerate(activity_dict['active_cfg_list'], start=1):
    print(index)</code></pre>
<p>可以快速的转为字典</p>
<pre><code class="language-python">order_dict = {order['order_id']: order for order in data['order_info_list']}</code></pre>
<h3>数值列表</h3>
<p>使用 range 创建数值列表，类似 php 里的迭代器，可以用于遍历</p>
<pre><code class="language-python">for ele in range(1,5):
    print(ele)</code></pre>
<p>对数字列表执行简单的统计计算</p>
<pre><code class="language-python">numbers = [1,2,3,4,5,6]
print(min(numbers))
print(max(numbers))
print(sum(numbers))</code></pre>
<p>列表解析，快速生成列表</p>
<pre><code class="language-python">numbers = [value**2 for value in range(1,3)]
print(numbers) # [1, 4]</code></pre>
<h3>切片</h3>
<p>还可以处理列表的部分元素，Python 称之为切片。左包含，右不包含</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]  
print(languages[0:2]) # ['PHP', 'Goland']  
print(languages[:2]) # ['PHP', 'Goland']  
print(languages[2:]) # ['Python', 'Java']  
print(languages[:]) # ['PHP', 'Goland', 'Python', 'Java']  
print(languages) # ['PHP', 'Goland', 'Python', 'Java']</code></pre>
<p>切片也可以遍历</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]
for ele in languages[:2]:  
    print(ele)</code></pre>
<p>如果要复制一份独立的列表，可以进行切片后复制，直接复制是引用</p>
<pre><code class="language-python">languages = ["PHP","Goland","Python","Java"]  
myL = languages[:]  
languages.pop()  
print(myL) # ["PHP","Goland","Python","Java"]</code></pre>
<h3>拼接字符串</h3>
<blockquote>
<p>用字符连接</p>
</blockquote>
<pre><code class="language-python">award_name_str = ",".join(award_name_list)</code></pre>
<h2>元组</h2>
<p>Python 将不能修改的值称为不可变的，而不可变的列表被称为 <strong>元组</strong>。不可修改!!</p>
<pre><code class="language-python">languages = ("PHP","Goland","Python","Java")  
print(languages[1])  
print(languages) # ('PHP', 'Goland', 'Python', 'Java')</code></pre>
<p>可以被遍历。</p>
<h2>格式</h2>
<p>要提出 Python 语言修改建议，需要编写 Python 改进提案（Python Enhancement Proposal，PEP）。PEP 8 是最古老的 PEP 之一，向 Python 程序员提供了代码格式设置指南。</p>
<ol>
<li>缩进：PEP 8 建议每级缩进都使用四个空格。而不是 tab 缩进。</li>
<li>PEP 8 还建议注释的行长不应超过 72 字符，因为有些工具为大型项目自动生成文档时，会在每行注释开头添加格式化字符</li>
<li>要将程序的不同部分分开，可使用空行</li>
<li>函数给形参指定默认值的时候，<code>=</code> 左右不能有空格，好像有空格也不会报错就是了</li>
</ol>
<h2>流程</h2>
<h3>条件测试</h3>
<ol>
<li>相等比较 <code>==</code>，区分大小写，如果不想区分的话，可以转为大写后再比较，注意，字符串的 1 和数值的 1 是不相等的</li>
<li>不相等比较 <code>!=</code>，都一样略过</li>
<li>数值比较，<code>&gt;,&gt;=,&lt;,&lt;=</code>，这个都一样，略过</li>
</ol>
<p>是否在列表中，使用关键字 in。</p>
<pre><code class="language-python">languages = ("PHP","Goland","Python","Java")  
if "PHP" in languages:  
    print("zai")</code></pre>
<p>是否不在列表中，使用关键字 in。</p>
<pre><code class="language-python">languages = ("PHP","Goland","Python","Java")  
if "js" not in languages:  
    print("不在")</code></pre>
<p>布尔表达式，字符串和布尔值比较的话，不管是 true 还是 false，都不会进去，数值类型可以比较</p>
<pre><code class="language-python">if "1.0" == True:  
    print("不能比较")</code></pre>
<p>多条件检查可以用：<strong>and、or</strong></p>
<h3>If</h3>
<p>每条 if 语句的核心都是一个值为 True 或 False 的表达式，这种表达式称为条件测试。也要缩进。并且 elif 和 else 是可以省略的</p>
<pre><code class="language-python"># if
name = '张三'  
if name == "张三":  
    print("是张三")

# if else
name = '张三'  
if name == "张三":  
    print("是张三")  
else:  
    print("不是张三")

# if elif else
name = '李四'  
if name == "张三":  
    print("是张三")  
elif name == "李四":  
    print("是李四")  
elif name == "王五":  
    print("是王五")
else:  
    print("不是张三和李四和王五")</code></pre>
<p>判断列表是否有值，不能和 true 和 false 比较，Python 将在列表至少包含一个元素时返回 True，并在列表为空时返回 False。</p>
<pre><code class="language-python">lan = [1]  
if lan:  
    print("aa")</code></pre>
<blockquote>
<p>三目运算</p>
</blockquote>
<pre><code class="language-python">server_id = int(params.get('server_id')) if params.get('server_id') else None</code></pre>
<blockquote>
<p>not in list 判断</p>
</blockquote>
<pre><code class="language-python"># not in list
if item["fake_amount"] not in amount_list:</code></pre>
<blockquote>
<p>is null 判断</p>
</blockquote>
<pre><code class="language-python"># 相当于is_null(fake_amount)
fake_amount is None</code></pre>
<blockquote>
<p>是否在数组或者集合中</p>
</blockquote>
<pre><code class="language-python"># check_config_ids = [1,2]
return config_id in set(check_config_ids)</code></pre>
<h3>While</h3>
<p>和其他语言一样，也可以使用 break 退出循环，使用 continue 跳过循环</p>
<pre><code class="language-python">current = 5  
while current &gt;= 0 :  
    print(current)  
    current -= 1</code></pre>
<p>Python 好像没有 for 循环，只有 for in 循环。</p>
<h2>字典</h2>
<p>在 Python 中，字典是一系列键值对。每个键都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。</p>
<pre><code class="language-python">person = {'name': 'zhangSang', 'age': 30}
print(person['name']) # key不存在也会报错
print(person.get("age",31)) # key不存在的话不会报错</code></pre>
<p>添加和修改元素，删除元素</p>
<pre><code class="language-python">person = {'name': 'zhangSang', 'age': 30}
person["name"] = "lisi" # 修改
person["sexy"] = "男" # 添加
del person['age'] # 删除
print(person)</code></pre>
<p>可以遍历</p>
<pre><code class="language-python"># 遍历key-value
person = {'name': 'zhangSang', 'age': 30}  
for key,value in person.items():  
    print(key,"=&gt;",value)

# 遍历key
person = {'name': 'zhangSang', 'age': 30}  
for key in person.keys():  
    print(key)

# 遍历值
person = {'name': 'zhangSang', 'age': 30}  
for value in person.values():  
    print(value)</code></pre>
<p>需要注意的是，如果没 key，则是集合</p>
<pre><code class="language-python">personSet = { 'zhangSang', 30}  
for value in personSet:  
    print(value)</code></pre>
<p>可以在字典中存储字典，也可以在字典中存储列表，具体忽略。</p>
<h2>输入</h2>
<p>可以使用 input 来获取输入</p>
<pre><code class="language-python">message = input("请输入：")  
print(message)</code></pre>
<p>因为输入的值，单做字符串，不可以和数值进行比较大小，否则会报错，所以要用 int 函数转换下</p>
<pre><code class="language-python">age = input("请输入年龄：")  
age = int(age)  
if age &gt;= 12 : # 需要转换下，不然这会报错  
    print(age)</code></pre>
<h2>函数</h2>
<p>简单的定义如下</p>
<pre><code class="language-python">def hello_world():  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print("hellow world")

hello_world()</code></pre>
<p>加上参数</p>
<pre><code class="language-python">def hello_world(name):  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print("hellow world",name)

hello_world("张三")</code></pre>
<p>还有一些知识点：</p>
<ol>
<li>传入参数可以位置实参，关键字实参。</li>
<li>形参的默认值和 php 都一样</li>
<li>返回也是和 php 一样。也可以返回多个值，接收变量也要对应</li>
<li>如果有要传入可变参数的话可以在形参前面加 <code>*</code>，例如 <code>def hello_world(*param):</code>，会创建一个空元组，类似 php 的 <code>function hello_world(…param)</code></li>
</ol>
<p>如果有要传入可变参数的话可以在形参前面加 <code>**</code>，可以传入键值对，存在字典中</p>
<pre><code class="language-python">def hello_world(**p):  
    """文档字符串的注释，用于描述函数是干嘛的"""  
    print(p)

hello_world(a=1,b=2) # {'a': 1, 'b': 2}</code></pre>
<p>参数后面的冒号是<strong>参数类型建议符，</strong>用来提供给程序员建议传入的实参类型，即使去掉也不会有任何影响。结尾的箭头 -&gt;代表着<strong> 函数返回值建议符，</strong>用来提供函数返回值的数据类型。</p>
<pre><code class="language-python">class Solution:
    def search(self, nums: List[int], target: int) -&gt; int:</code></pre>
<h2>模块</h2>
<p>模块是扩展名为 <code>.py</code> 的文件，包含要导入到程序中的代码。通过将 <strong>函数和类</strong> 等存储在称为模块的独立文件中，再将模块导入到主程序中使用，可以使得代码更加清晰。模块名称就是文件名称。</p>
<p>然后直接导入后就可以使用，导入的时候，首先会从当前目录查找该模块的文件名称，然后将它复制过来 <strong>执行</strong>。导入方式有：</p>
<pre><code class="language-python"># 导入整个模块内容
import hello
# 导入模块中的函数、类、变量啥的
from hello import hello_world
# 换行的话，要用\
from hello import hello_world1,hello_world2,\
hello_wordl3
from hello import * # 导入所有函数

# as 起别名
from hello import hello_world as hw
import hello as hl
</code></pre>
<p>注意：导入就是将代码复制过来，导入的时候会执行模块文件里的代码。但是在一个模块来重复导入其他模块，只会执行一次。</p>
<h2>包</h2>
<p>目录中有 <code>__init__.py</code> 的就是包，所以可以说包就是目录，一个包里有很多个模块，模块就是一个文件。可以用 import 导入包。</p>
<h2>类</h2>
<p>简单的声明如下：</p>
<pre><code class="language-python">class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age

def get_name(self):  
        print(self.name)

p = Person("张三")  
p.get_name()  
print(p.name,p.age)</code></pre>
<p>首字母大写的代表是类，调用的时候，表示实例化，区分函数调用，不过这只是规范而已。</p>
<blockquote>
<p>构造函数</p>
</blockquote>
<p>这个是构造函数，实例化的时候会自动调用。有三个参数，形参 self 必不可少，而且必须位于其他形参的前面，实例化的时候将自动传入实参 self。每个与实例相关联的方法调用都自动传递实参 self，它是一个指向实例本身的引用。</p>
<h3>继承</h3>
<p>简单的使用如下，继承 Person 类</p>
<pre><code class="language-python">class BlackPerson(Person):  
    def __init__(self, name, age):  
        super().__init__(name, age)  
        self.skin = "黑色皮肤" # 子类特有的属性

def get_skin(self):  
        print(self.skin)

p = BlackPerson("Jack张", 18)  
p.get_addr()  
p.get_skin()</code></pre>
<p>super () 是一个特殊函数，让你能够调用父类的方法。</p>
<h2>文件</h2>
<h3>读取</h3>
<p>简单的语法如下所示，读取整个文件：</p>
<pre><code class="language-python">with open("text.txt") as file_object:  
    contents = file_object.read()

print(contents.rstrip()) # 好像read的末尾多了一个空行</code></pre>
<p>关键字 with 在不再需要访问文件后将其关闭，因为我们调用了 open ()，但没有调用 close ()，with 会自动在合适的时候关闭它。</p>
<p>还可以逐行读取</p>
<pre><code class="language-python">with open("text.txt") as file_object:  
    for line in file_object:  
        print(line)</code></pre>
<p>还可以获取列表的行内容：</p>
<pre><code class="language-python">with open("text.txt") as file_object:  
    lines = file_object.readlines()

print(lines)</code></pre>
<p>还可以通过文件里解析 json 的格式内容</p>
<pre><code class="language-python">with open("text.txt") as file_object:  
    contents = json.load(file_object)

print(contents)</code></pre>
<h3>写入</h3>
<p>简单的使用如下，可以选择模式，是追加还是覆盖</p>
<pre><code class="language-python">with open("text.txt",'w') as file_object:  
    lines = file_object.write("haha")</code></pre>
<p>还可以写入 json 数据</p>
<pre><code class="language-python">person = {  
    "name":"张三",  
    "age":20,  
}  
with open("text.txt",'w') as file_object:  
    json.dump(person,file_object)</code></pre>
<h2>异常</h2>
<p>简单是使用如下所示：</p>
<pre><code class="language-python">try:  
    answer = 5/1  
except ZeroDivisionError:  
    print("除数不能为0")  
else:  
    print(answer)</code></pre>
<p>如果没有异常就会执行 else 分支。</p>
<p>如果捕获异常后什么都不要做的话，可以使用 pass。pass 语句还充当了占位符，提醒你在程序的某个地方什么都没有做，并且以后也许要在这里做些什么。</p>
<pre><code class="language-python">try:  
    answer = 5/0  
except ZeroDivisionError:  
    pass  
else:  
    print(answer)</code></pre>
<h2>单元测试</h2>
<p>简单使用</p>
<pre><code class="language-python">class TestHelloCase(unittest.TestCase):  # 要继承这个类
    def test_hello_world(self):  
        tmp = hello.hello_world() # 这个返回值进行比较  
        self.assertEqual(tmp,"hello word")  # 断言

if __name__ == '__main__':  # 防止导入的时候被执行
    unittest.main()</code></pre>
<p>如果测试的是类，经常需要在方法里重复实例化，如果想要只实例化一次，可以使用 setup 方法存起来。</p>
<p><code>__name__</code> 是用来标识模块名字的一个系统变量。这里分两种情况：</p>
<ol>
<li>第一种情况指的是当前运行的模块，那么当前模块 <code>__name__</code> 的值就为 "main"；</li>
<li>第二种情况指的是该模块是使用 import 导入的模块，那么这个被导入模块的 <code>__name__</code> 变量的值为该模块的文件名（去掉. py）</li>
</ol>

基础知识

变量

字符串

数

注释

列表介绍

访问

增删改

排序

遍历

数值列表

切片

拼接字符串

元组

格式

流程

条件测试

If

While

字典

输入

函数

模块

包

类

继承

文件

读取

写入

异常

单元测试

发表评论 取消回复 使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款

Python基础教程 - 从入门到精通

发表评论取消回复
使用cookie技术保留您的个人信息以便您下次快速评论，继续评论表示您已同意该条款