一天快速入门 Python
发布时间:2019-11-06 12:16

原标题:一天快速入门 Python

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

作者 | yuquanle

责编 | 屠敏

Python基本语法

标识符

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

保留字

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

importkeyword

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"]

基本数据类型

计算机程序要处理不同的数据,需要定义不同的数据类型。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)

deldict1[ '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

ifx > 3:

print( "yes")

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

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

x = 99

ifx< 60:

print( "不及格")

elif x< 80:

print( "良好")

else:

print( "优秀")

# while循环

sum = 0

counter = 1

whilecounter <= 10:

sum = sum + counter

counter += 1

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

# while循环使用 else语句

count = 0

whilecount < 5:

print(count, " 小于 5")

count = count + 1

else:

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

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

str = 'python'

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

print( "遍历字符串")

fori instr:

print(i)

print( "遍历列表")

fori inlist1:

print(i)

#range函数:遍历数字序列,可以使用内置range函数生成数列

fori inrange( 5):

print(i)

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

fori inrange( 2, 6):

print(i)

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

fori inrange( 0, 10, 3):

print(i)

fori inrange( -10, -100, -30):

print(i)

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

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

fori inrange(len(list1)):

print(list1[i])

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

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

fori inlist1:

ifi == 'love':

break

print( '当前为 :', i)

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

var= 10

whilevar> 0:

var= var-1

# 变量为 5时跳过输出

ifvar== 5:

continue

print( '当前值 :', var)

print( "hello world!")

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

whileTrue:

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

函数

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

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

# 1.无参函数

# 用def定义新函数

defmy_func:

print( "test...")

return1

# 调用函数

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 = 0

forn innumbers:

sum = sum + n * n

returnsum

# 函数调用

my_func3 #返回结果0

my_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

classStudent(object):

"学生成绩"

def__init__(self, name, score):

self.name = name

self.score = score

defprint_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' 属性

deljack.age

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

类的继承

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

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

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

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

classFruit(object):

'父类Animal'

defrun_father(self):

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

classApple(Fruit):

'子类1 Apple'

defrun_son(self):

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

classOrange(Fruit):

'子类2 Orange'

defrun_son(self):

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

#实例化子类

apple = Apple

orange = Orange

#调用父类方法

apple.run_father

orange.run_father

#调用子类方法

apple.run_son

orange.run_son

方法重写

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

classFruit(object):

'父类Animal'

defrun(self):

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

classApple(Fruit):

'子类1 Apple'

defrun(self):

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

classOrange(Fruit):

'子类2 Orange'

defrun(self):

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

#实例化子类

apple = Apple

orange = Orange

#调用父类方法

apple.run

orange.run

模块

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

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

# 导入模块

importmath

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

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

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

# 导入模块中的特定函数

frommath importexp

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

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

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

frommath import*

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

点击阅读原文,加入 CSDN 吧!