一天快速入门 Python

lbk60ox

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

作者 | yuquanle

责编 | 屠敏

Python基本语法

标识符

第1个字符必要是英文字母或下划线 _ 。标识符的其他的部分由字母、数字和下划线构成。标识符对体积写敏锐。

保存字

保存字即关键字，不可用作任何标识符名叫作。keyword 模块能够输出当前版本的所相关键字：

import keywordprint(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"

]

基本数据类型

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

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

数字类型(Number)

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

# int

(整数)

a = 3

# float(浮点数)

b = 3.5#bool

(布尔)

c = True

#complex

(复数)

d = 4+3

j

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 pythonprint

(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(I\nlove\npython

)

print("反斜杠转义失效:",rI\nlove\npython)

列表类型(List)

列表类型是一种有序的集合。列表中元素的类型能够不相同，它支持数字，字符串乃至能够包括列表（所说嵌套）。列表是写在方括号 之间、用逗号分隔开的元素列表。

list_a = [1, 2, 3, 4, 5, 6]list_b = [7, 8, 9]print(list_a)print(list_b)#列表能够被索引和截取，列表被截取后返回一个包括所需元素的新列表print ("输出完整列表: ", list_a)print ("输出列表第1个元素:", 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] = 0list_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 = 123456print("转换后：", list(str))#count办法：统计某个元素在列表中显现的次数list_a = [1, 1, 2, 3, 4, 5, 6]print("1在list_a中显现的次数：", list_a.count(1))#index办法：从列表中找出某个值第1次显现的索引位置list_a = [1, 2, 3, 4, 5, 6]print("3第1次显现的位置：", 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("指定移除第1个元素：", list_a.pop(0))#reverse办法：翻转列表中元素list_a = [1, 2, 3, 4, 5, 6]print("翻转前：", list_a)list_a.reverseprint("翻转后：", list_a)#sort办法：该办法无返回值，然则对原列表进行排序list_a = [1, 3, 2, 5, 4, 6]print("排序前：", list_a)list_a.sortprint("升序排序：", 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] = 3print ("增多后："

, 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 = 5if x > 3

:

print("yes"

)

#if嵌套:if...elif...else#亦能够把 if...elif...else 结构放在另一一个 if...elif...else

结构中

x = 99if x<60

:

print("不及格"

)

elif x<80

:

print("良好"

)

else

:

print("优秀"

)

#while循环

sum = 0counter = 1while counter <= 10

:

sum = sum + counter

counter += 1print("1 到 10 之和为: %d"

% sum)

#while 循环运用 else

语句

count = 0while count < 5

:

print (count, " 少于 5"

)

count = count + 1else

:

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

)

#for 语句：for

循环能够遍历任何序列(列表、字符串等)

str = pythonlist1 = [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:

ifi ==love

:

break

print(当前为 :

, i)

#continue

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

var = 10while var > 0

:

var = var -1# 变量为 5

时跳过输出

if var == 5

:

continue

print (当前值 :, var

)

print ("hello world!"

)

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

while True:

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

函数

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

Python供给了许多内建函数，例如“print”，亦能够自己创建函数，这被叫做用户自定义函数。

# 1.

无参函数

# 用def定义新函数

defmy_func

:

print("test..."

)

return 1

# 调用函数

my_func

# 2.

有参函数

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

# 关键字参数: 调用时指定参数的名叫作，且与函数声明时的参数名叫作一致。运用关键字参数准许函数调用时参数的次序与声明时不一致。

defmy_func1(x, y)

:

print

(x)

print

(y)

# 标准调用

my_func1(1, 2

)

# 关键字调用

defmy_func1(y = 1, x = 2)

# 默认参数：在函数声明时，指定形参的默认值，调用时可不传入参数（运用默认值）。

defmy_func2(x, y=1)

:

print

(x+y)

my_func2(2

)

#可变参数:变参数便是传入的参数个数是可变的，能够是1个、2

个到任意个。

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

defmy_func3(*numbers)

:

sum = 0for

n in numbers:

sum = sum + n * n

return sum

# 函数调用

my_func3 #返回结果0my_func3(1,2) #返回结果5# 关键字参数：可变参数准许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数准许你传入0

个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

defmy_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 = 7print("添加一个 age 属性：",hasattr(jack, age

))

# 修改 age

属性

jack.age = 8print("修改 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):父类Animaldef run(self):print(调用父类办法...

)

class Apple(Fruit):子类1 Appledef run(self):print(子类1 Apple 重写父类办法...

)

class Orange(Fruit):子类2 Orangedef run(self):print(子类2 Orange 重写父类办法...

)

#实例化子类apple = Appleorange = Orange#调用父类办法apple.runorange.run

模块

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

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

# 导入模块

import math

# 此刻能够调用模块里包括的函数了

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

))

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

# 导入模块中的特定函数

from mathimportexp

# 此刻能够直接运用该函数了

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

))

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

from math import *

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

【END】

akbchina.cn

感谢你的精彩评论，带给我新的思考角度。