一天快速入门python_一天快速入门 Python

旧城等待， 2022-10-28 03:50 9阅读 0赞

Python 是由Guido Van Rossum在 90 年代早期设计，现在是最常用的编程语言之一。特别是人工智能的火热，再加之它的语法简洁且优美，实乃初学者入门AI必备的编程语言。

![246d40f743be5093a89cae6c1c36f747.png][]

作者 |yuquanle

责编 | 屠敏

![4e2d0bbd811292d361b9a9e7c14a7ca1.png][]

Python基本语法

标识符

第一个字符必须是英文字母或下划线 \_ 。标识符的其他的部分由字母、数字和下划线组成。标识符对大小写敏感。

保留字

保留字即关键字，不能用作任何标识符名称。keyword 模块可以输出当前版本的所有关键字：

import keyword

print(keyword.kwlist)

\['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'\]

注释

单行注释采用\#，注释是给人看的，可以是任意内容，解释器会忽略掉注释。

多行注释采用'''或"""。

\# print("我是注释，不会执行")

print("正常执行代码")

'''

这是多行注释，用三个单引号

'''

print("Hello, World!")

"""

这是多行注释，用三个双引号

"""

print("Hello, World!")

行与缩进

Python 使用缩进来表示代码块而不是大括号 \{\}。缩进的空格数是可变的，但是同一个代码块的语句必须是相同的缩进空格数。建议四个空格数。

注意Tab和四格空格混用会报错，这个错误还不容易被察觉。

输入输出

通常是一条语句一行，如果语句很长，我们可以使用反斜杠()来实现多行语句。在 \[\], \{\}, 或 () 中的多行语句，则不需要反斜杠。

sentence1 = "I love " +

"python"

sentence2 = \["I", "love",

"python"\]

![f20c3c0e06c2e95f8676215464172dbb.png][]

基本数据类型

计算机程序要处理不同的数据，需要定义不同的数据类型。Python 中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

Python中变量就是变量，没有类型，所说的"类型"是变量所指的内存中对象的类型。等号(=)用来给变量赋值。等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

数字类型(Number)

数字类型是不可变数据。Python3 支持 int(整数)、float(浮点数)、bool(布尔)、complex(复数)，数值类型的赋值和计算是很直观的。

\# int(整数)

a = 3

\# float(浮点数)

b = 3.5

\#bool(布尔)

c = True

\#complex(复数)

d = 4+3j

print(a, b, c, d)

\#内置的 type() 函数可以用来查询变量所指的对象类型

print(type(a), type(b), type(c), type(d))

\#还可以用 isinstance 来判断

\#isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型

print(isinstance(a, int))

print(isinstance(a, float))

关于数值运算，可以同时为多个变量赋值，如a, b = 1, 2。一个变量可以通过赋值指向不同类型的对象。

除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。混合计算时，Python会把整型转换成为浮点数。

\# 加

print("Add operation: 5 + 4 = ",5 + 4)

\# 减

print("Sub operation: 5 - 4 = ",5 - 4)

\# 乘

print("Mul operation: 5 \* 4 = ",5 \* 4)

\# 除，得到一个浮点数

print("Div operation: 5 / 4 = ",5 / 4)

\# 除，得到一个整数

print("Div operation: 5 // 4 = ",5 // 4)

\# 取余

print("Mod operation: 5 % 4 = ",5 % 4)

\# 乘方

print("Pow operation: 5 \*\* 4 = ",5 \*\* 4)

字符串类型(String)

Python 没有单独的字符类型，一个字符就是长度为1的字符串。字符串用单引号 ' 或双引号 " 括起来。

s1 = "I love python"

s2 = 'I love python'

print(s1)

print(s2)

\#索引值以 0 为开始值，-1 为从末尾的开始位置

print("s1首字母字符：", s1\[0\])

print("s1末尾字母字符：",  s1\[-1\])

print("输出从第三个开始到第五个的字符:", s1\[2:5\])

\#加号 + 是字符串的连接符

\#星号 \* 表示复制当前字符串，紧跟的数字为复制的次数

str = "I love python "

print("连接字符串:", str + "!!!")

print("输出字符串两次:", str \* 2)

\#反斜杠  转义特殊字符

\#若不想让反斜杠发生转义，可以在字符串前面添加一个 r

print('Inlovenpython')

print("反斜杠转义失效:",r'Inlovenpython')

列表类型(List)

列表类型是一种有序的集合。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号 \[\] 之间、用逗号分隔开的元素列表。

list\_a = \[1, 2, 3, 4, 5, 6\]

list\_b = \[7, 8, 9\]

print(list\_a)

print(list\_b)

\#列表可以被索引和截取，列表被截取后返回一个包含所需元素的新列表

print ("输出完整列表: ", list\_a)

print ("输出列表第一个元素:", list\_a\[0\])

print ("从第二个开始输出到第三个元素:", list\_a\[1:3\])

print ("输出从第三个元素开始的所有元素:", list\_a\[2:\])

print ("连接两次列表:", list\_a \* 2)

print ("连接列表:", list\_a + list\_b)

\#列表中的元素是可以改变的

list\_a = \[1, 2, 3, 4, 5, 6\]

print("变化前：", list\_a)

list\_a\[0\] = 0

list\_a\[2:5\] = \[7, 8, 9\]

print("变化后：", list\_a)

\#append()方法：在列表末尾添加新的对象

list\_a = \[1, 2, 3, 4, 5, 6\]

print("添加前：", list\_a)

list\_a.append(7)

list\_a.append(8)

print("添加后：", list\_a)

\#del语句：删除列表元素

list\_a = \[1, 2, 3, 4, 5, 6\]

print("删除前：", list\_a)

del list\_a\[0\]

print("删除后：", list\_a)

\#len()方法：计算列表长度

list\_a = \[1, 2, 3, 4, 5, 6\]

print("列表长度：", len(list\_a))

\#max()方法：返回列表元素最大值。min()方法：返回列表元素最小值

list\_a = \[1, 2, 3, 4, 5, 6\]

print("列表最小值：", min(list\_a))

print("列表最大值：", max(list\_a))

\#list()方法：将字符串转换为列表

str = '123456'

print("转换后：", list(str))

\#count()方法：统计某个元素在列表中出现的次数

list\_a = \[1, 1, 2, 3, 4, 5, 6\]

print("1在list\_a中出现的次数：", list\_a.count(1))

\#index()方法：从列表中找出某个值第一次出现的索引位置

list\_a = \[1, 2, 3, 4, 5, 6\]

print("3第一次出现的位置：", list\_a.index(3))

\#insert()方法：将对象插入列表指定位置

list\_a = \[1, 2, 3, 4, 5, 6\]

print("插入前：", list\_a)

list\_a.insert(0 ,7)

print("插入后：", list\_a)

\#pop()方法：移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

list\_a = \[1, 2, 3, 4, 5, 6\]

print("默认移除最后一个元素：", list\_a.pop())

print("指定移除第一个元素：", list\_a.pop(0))

\#reverse()方法：翻转列表中元素

list\_a = \[1, 2, 3, 4, 5, 6\]

print("翻转前：", list\_a)

list\_a.reverse()

print("翻转后：", list\_a)

\#sort()方法：该方法没有返回值，但是对原列表进行排序

list\_a = \[1, 3, 2, 5, 4, 6\]

print("排序前：", list\_a)

list\_a.sort()

print("升序排序：", list\_a)

list\_a.sort(reverse = True)

print("降序排序：", list\_a)

元组类型(Tuple)

元组类型是不可变类型，元组使用小括号()。

tup1 = (1, 2, 3, 4, 5 )

\# 元组中只包含一个元素时，需要在元素后面添加逗号,否则括号会被当作运算符使用

tup2 = (50,)

tup3 = (50)

print(type(tup2))

print(type(tup3))

\#访问元组:使用下标索引来访问元组中的值

tup1 = (1, 2, 3, 4, 5 )

print ("tup1\[0\]: ", tup1\[0\])

print ("tup1\[1:3\]: ", tup1\[1:3\])

\#修改元组:元组中的元素值是不允许修改的，但可以对元组进行连接组合

tup1 = (1, 2)

tup2 = ('a', 'b')

\# 创建一个新的元组

tup3 = tup1 + tup2

print(tup3)

\#删除元组：元素值是不允许删除，但可以使用del语句来删除整个元组

tup1 = (1, 2, 3, 4, 5 )

print(tup1)

del tup1

print("删除后的元组 tup1: ")

print(tup1)

\#元组运算符：如 + 号和 \* 号

tup1 = (1, 2)

tup2 = ('a', 'b')

print("连接：", tup1 + tup2)

print("复制3次：", tup1 \* 3)

\#len()：计算元组元素个数

tup1 = (1, 2)

print("元组长度：", len(tup1))

\#max()方法: 返回元组中元素最大值。min()方法: 返回元组中元素最小值

tup1 = (1, 2)

print("元组最大值：", min(tup1))

print("元组最大值：", max(tup1))

\#tuple()方法：将列表转换为元组

list1= \['1', '2'\]

print("转换前：", list1)

tup1 = tuple(list1)

print("转换后：", tup1)

集合类型(Set)

集合类型是无序的不重复元素序列。使用大括号 \{\} 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 \{\}，因为 \{\} 是用来创建一个空字典。

a=\{'a','b','c'\}

b=set('abc')

c=set()

d=\{\}

print(a)

print(b)

print(type(a), type(b), type(c), type(d))

\#无序性

a = set('python')

print(a)

\#互异性

a = set('good')

print(a)

\#add()方法：为集合添加元素

a = set('good')

a.add('p')

print(a)

\#update()方法：给集合添加元素

a = set('good')

a.update('p')

print("添加一个元素", a)

a.update(\['a', 'b', 'c'\])

print("添加多个元素", a)

a.update(\['H', 'e'\], \{'l', 'l', 'o'\})

print('添加列表和集合', a)

\#remove()方法：移除指定元素

s = \{'P', 'y', 't', 'h', 'o', 'n'\}

s.remove('t')

print("去掉t", s)

\#pop()方法：随机移除元素

s = \{'P', 'y', 't', 'h', 'o', 'n'\}

print("随机删除元素：", s.pop())

\#clear()方法：移除集合中的所有元素

s = \{'P', 'y', 't', 'h', 'o', 'n'\}

s.clear()

print("清空集合：", s, len(s))

\#issubset()方法：判断指定集合是否为该方法参数集合的子集

A = set('abcd')

B = set('cdef')

C = set('ab')

print("C是否A子集：", C.issubset(A))

\#union()方法：返回两个集合的并集，也可以用 |

print("A和B并集:", A|B)

print("A和B并集:",A.union(B))

\#intersection()方法：返回集合的交集，也可以用&

print("A和B交集:", A&B)

print("A和B交集:",A.intersection(B))

\#difference()方法：差集，也可以用-

print("A和B差集:", A-B)

print("A和B差集:",A.difference(B))

字典类型(Dictionary)

字典类型是可变类型。在同一个字典中，键(key)必须是唯一的。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号(\{\})中。

\# 用\{\}创建字典

dict1 = \{"a":"1", "b":"2"\}

print(dict1)

\# 用内置函数dict()

dict2 = dict(a="1", b="2")

print(dict2)

\#访问字典里的值

dict1 = \{"a":"1", "b":"2"\}

print ("dict1\['a'\]: ", dict1\['a'\]) \#如果没有会报错

print ("dict1.get('a'): ", dict1.get('a')) \#如果没有返回None

print("获取所有的key值：", dict1.keys())

print("获取所有的value值：", dict1.values())

\#增加新的键/值对

dict1 = \{"a":"1", "b":"2"\}

print ("增加前：", dict1)

dict1\['c'\] = 3

print ("增加后：", dict1)

\#删除字典指定元素

dict1 = \{"a":"1", "b":"2"\}

print ("删除前：", dict1)

del dict1\['a'\]

print ("删除后：", dict1)

\#清空字典

dict1 = \{"a":"1", "b":"2"\}

print ("清空前：", dict1)

dict1.clear()

print ("清空后：", dict1)

\#dir()方法：查看dict所有方法

print(dir(dict))

条件判断和循环

条件控制：通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。

每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。在Python中没有switch–case语句。

\#if操作

x = 5

if x > 3:

print("yes")

\#if嵌套:if...elif...else

\#也可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中

x = 99

if x<60:

print("不及格")

elif x<80:

print("良好")

else:

print("优秀")

\#while循环

sum = 0

counter = 1

while counter <= 10:

sum = sum + counter

counter += 1

print("1 到 10 之和为: %d" % sum)

\#while 循环使用 else 语句

count = 0

while count

print (count, " 小于 5")

count = count + 1

else:

print (count, " 大于或等于 5")

\#for 语句：for循环可以遍历任何序列(列表、字符串等)

str = 'python'

list1 = \['I', 'love', 'python'\]

print("遍历字符串")

for i in str:

print(i)

print("遍历列表")

for i in list1:

print(i)

\#range()函数：遍历数字序列，可以使用内置range()函数生成数列

for i in range(5):

print(i)

\#也可以使用range指定区间的值

for i in range(2,6):

print(i)

\#也可以使range以指定数字开始并指定不同的增量(步长),可以是负数

for i in range(0, 10, 3):

print(i)

for i in range(-10, -100, -30):

print(i)

\#可以结合range()和len()函数以遍历一个序列的索引

list1 = \['I', 'love', 'Python'\]

for i in range(len(list1)):

print(list1\[i\])

\#break语句：跳出 for 和 while 的循环体

list1 = \['I', 'love', 'Python'\]

for i in list1:

if i == 'love':

break

print('当前为 :', i)

\#continue语句:跳过当前循环块中的剩余语句，然后继续进行下一轮循环

var = 10

while var > 0:

var = var -1

\# 变量为 5 时跳过输出

if var == 5:

continue

print ('当前值 :', var)

print ("hello world!")

\#pass 语句：pass是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用做占位语句

while True:

pass  \# 等待键盘中断 (Ctrl+C)

![c24431531fe62353002a162a54c56e2f.png][]

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

Python提供了许多内建函数，比如“print()”，也可以自己创建函数，这被叫做用户自定义函数。

\# 1.无参函数

\# 用def定义新函数

def my\_func():

print("test...")

return 1

\# 调用函数

my\_func()

\# 2.有参函数

\# 关键字参数、默认参数、可变参数。

\# 关键字参数: 调用时指定参数的名称，且与函数声明时的参数名称一致。使用关键字参数允许函数调用时参数的顺序与声明时不一致。

def my\_func1(x, y):

print(x)

print(y)

\# 标准调用

my\_func1(1, 2)

\# 关键字调用

def my\_func1(y = 1, x = 2)

\# 默认参数：在函数声明时，指定形参的默认值，调用时可不传入参数(使用默认值)。

def my\_func2(x, y=1):

print(x+y)

my\_func2(2)

\#可变参数:变参数就是传入的参数个数是可变的，可以是1个、2个到任意个。

\#在参数前面加了一个\*号。在函数内部，参数numbers接收到的是一个tuple。

def my\_func3(\*numbers):

sum = 0

for n in numbers:

sum = sum + n \* n

return sum

\# 函数调用

my\_func3()     \#返回结果0

my\_func3(1,2)  \#返回结果5

\# 关键字参数：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def my\_func4(x, \*\*kw):

print ('x:', x, 'other:', kw)

\#除了必选参数x外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数。

my\_func4(8)

\#也可以传入任意个数的关键字参数

my\_func4(8, z="66")

类

类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

\#创建类Student

class Student(object):

"学生成绩"

def \_\_init\_\_(self, name, score):

self.name = name

self.score = score

def print\_score(self):

print('%s: %s' % (self.name, self.score))

\#创建Student类的对象bart

jack = Student('Bart Simpson', 59)

\#创建Student类的对象lisa

bob = Student('Lisa Simpson', 87)

\#访问类的属性

jack.print\_score()

bob.print\_score()

\# 添加一个 'age' 属性

jack.age = 7

print("添加一个 'age' 属性：",hasattr(jack, 'age'))

\# 修改 'age' 属性

jack.age = 8

print("修改 'age' 属性：",getattr(jack, 'age'))

\# 删除 'age' 属性

del jack.age

print("删除 'age' 属性：",hasattr(jack, 'age'))

类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

\#编写一个名为Fruit的class，执行run()方法可以直接打印

\#编写Apple和Orange类时，就可以直接从Fruit类继承

class Fruit(object):

'父类Animal'

def run\_father(self):

print('调用父类方法...')

class Apple(Fruit):

'子类1 Apple'

def run\_son(self):

print('调用子类方法...')

class Orange(Fruit):

'子类2 Orange'

def run\_son(self):

print('调用子类方法...')

\#实例化子类

apple = Apple()

orange = Orange()

\#调用父类方法

apple.run\_father()

orange.run\_father()

\#调用子类方法

apple.run\_son()

orange.run\_son()

方法重写

如果父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

class Fruit(object):

'父类Animal'

def run(self):

print('调用父类方法...')

class Apple(Fruit):

'子类1 Apple'

def run(self):

print('子类1 Apple 重写父类方法...')

class Orange(Fruit):

'子类2 Orange'

def run(self):

print('子类2 Orange 重写父类方法...')

\#实例化子类

apple = Apple()

orange = Orange()

\#调用父类方法

apple.run()

orange.run()

![8e8b979b66c15a061306d07ac620d342.png][]

模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。模块能定义函数，类和变量，模块里也能包含可执行的代码。

\# 导入模块

import math

\# 现在可以调用模块里包含的函数了

print("求e的n次幂：",math.exp(1))

\# from…import 语句：从模块中导入一个指定的部分到当前命名空间中

\# 导入模块中的特定函数

from math import exp

\# 现在可以直接使用该函数了

print("求e的n次幂：",exp(1))

\# from…import\* 语句：导入一个模块中的所有项目。然而这种声明不该被过多地使用

from math import \*

声明：本文为公众号「 AI小白入门」投稿，版权归作者所有。

【END】

![20aeb768c3014a24837b07adea262b80.png][]

热 文 推 荐

☞一文了解超级账本DLT、库、开发工具有哪些, Hyperledger家族成员你认识几个？

![07be1124e8c24f87d16901f321cf4df0.gif][]点击阅读原文，加入 CSDN 吧！

![58f18f6f83ccffbfdd8097bb01cbd85c.png][]

你点的每个“在看”，我都认真当成了喜欢

[246d40f743be5093a89cae6c1c36f747.png]: /images/20221024/394e49e54da746a68d173214c3aad643.png
[4e2d0bbd811292d361b9a9e7c14a7ca1.png]: /images/20221024/17308d5d476441598804091071936eb7.png
[f20c3c0e06c2e95f8676215464172dbb.png]: /images/20221024/bc328ed3c252465e80bce3577086df1c.png
[c24431531fe62353002a162a54c56e2f.png]: /images/20221024/391d763f908e4d49ad1f055c965f2df0.png
[8e8b979b66c15a061306d07ac620d342.png]: /images/20221024/8830a6aff5da47ada4a8c58017d4551c.png
[20aeb768c3014a24837b07adea262b80.png]: /images/20221024/34c1f7dd04104874b49b0f689f625d55.png
[07be1124e8c24f87d16901f321cf4df0.gif]: /images/20221024/c4d04923fc6943f799c37d918c903232.png
[58f18f6f83ccffbfdd8097bb01cbd85c.png]: /images/20221024/a6d17878477f4672abcc3d7ec2484b3c.png