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】
|