python基础语法学习

简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。 Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

文章目录

• • 简介
  • 一、基础语法
  • • 1.标识符
    • 2.注释
  • 二、数据类型
  • • 1.标准数据类型
    • 2.Number
    • 3.String（字符串）
    • 4.列表
    • 5.元组
    • 6.字典
    • 7.集合
  • 三、语句结构
  • • 1.条件控制
    • 2.循环语句
  • 四、输入输出
  • • 1.输出
    • 2.输入
  • 五、函数
  • • 1.函数的定义
    • 2.参数传递
    • 3.匿名函数
  • 六、File(文件) 方法
  • • 1.open()方法
    • 2.file对象
  • 七、模块
  • • 1.import语句
    • 2.from...import语句
    • 3.from … import * 语句
  • 八、面向对象
  • • 1.类定义
    • 2.类的属性与方法
    • 3.构造方法
    • 4.类的方法
    • 5.继承
    • 6.方法重写

一、基础语法

1.标识符

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

2.注释

Python中单行注释以 # 开头，实例如下：

# 第一个注释
print ("Hello, Python!") # 第二个注释
           

多行注释可以用多个 # 号，还有 ‘’’ 和 “”"：

# 第一个注释
# 第一个注释
# 第二个注释
 
'''
第三注释
第四注释
'''
 
"""
第五注释
第六注释
"""
print ("Hello, Python!")
           

二、数据类型

1.标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）
• Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

2.Number

Python3 支持 int、float、bool、complex（复数）。（在Python 3里，只有一种整数类型 int，表示为长整型。）

代码如下（示例）：

a, b, c, d = 20, 5.5, True, 4+3j
 print(type(a), type(b), type(c), type(d))
 #<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
           

Python 数字类型转换：

• int(x) 将x转换为一个整数。
• float(x) 将x转换到一个浮点数。
• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

注意：

1、Python可以同时为多个变量赋值，如a, b = 1, 2。

2、一个变量可以通过赋值指向不同类型的对象。

3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

4、在混合计算时，Python会把整型转换成为浮点数。

3.String（字符串）

• 字符串的定义

  可以使用引号( ’ 或 " )来创建字符串，示例如下：

str1 = 'Hello World!'
str2 = "Hello Python!"
           

• 访问字符串中的值

  Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

  Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

#变量[头下标:尾下标]
str1 = 'Hello World!'
str2 = "Hello Python!"
print(str1[0]) #H
print(str2[1:5) #ello
           

• 字符串运算符

  +：字符串的连接

  *：重复输出字符串

  []：通过索引获取字符

  [:] : 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。

  in: 成员运算符 - 如果字符串中包含给定的字符返回 True

  not in: 成员运算符 - 如果字符串中不包含给定的字符返回 True

  %: 格式字符串

• 字符串格式化

  1. %c ：格式化字符及其ASCII码

  2. %s ： 格式化字符串

  3. %d ： 格式化整数

  4. %u ： 格式化无符号整型

  5. %o ： 格式化无符号八进制数

  6. %x ： 格式化无符号十六进制数

  7. %X： 格式化无符号十六进制数（大写）

  8. %f ： 格式化浮点数字，可指定小数点后的精度

  9. %e ： 用科学计数法格式化浮点数

  10. %E ： 作用同%e，用科学计数法格式化浮点数

  11. %g ：%f和%e的简写

  12. %G ：%f 和 %E 的简写

  13. %p ：用十六进制数格式化变量的地址

示例代码：

4.列表

1. 列表创建

   创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['hello', 'World', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
           

1. 访问列表中的值

   与字符串的索引一样，列表索引从 0 开始,实例：

list = ['hello', 'World', 1997, 2000]
 print( list[0] ) #hello
 print( list[1] ) #World
 print( list[2] ) #1997
 print(	list[-1]) #2000
 print( list[-2] ) #1997
 # 从第二位开始（包含）截取到倒数第一位（不包含）
print ("list[1:-2]: ", list[1:-1]) #World 1997
           

1. 删除列表中的元素

list = ['hello', 'World', 1997, 2000]
 print ("原始列表 : ", list) #['hello', 'World', 1997, 2000]
 del list[2]
 print ("删除第三个元素 : ", list) #['hello', 'World',2000]
           

1. 列表函数&方法

   1，len(list)

   列表元素个数

   2，max(list)

   返回列表元素最大值

   3，min(list)

   返回列表元素最小值

   4，list(seq)

   将元组转换为列表

   5，list.append(obj)

   在列表末尾添加新的对象

   6，list.count(obj)

   统计某个元素在列表中出现的次数

   7，list.extend(seq)

   在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

   8，list.index(obj)

   从列表中找出某个值第一个匹配项的索引位置

   9，list.insert(index, obj)

   将对象插入列表

   10，list.remove(obj)

   移除列表中某个值的第一个匹配项

   11， list.sort( key=None, reverse=False)

   对原列表进行排序

   12，list.clear()

   清空列表

   13，list.copy()

   复制列表

5.元组

元组与列表类似，不同之处在于元组的元素不能修改。

1. 创建元组

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

1. 访问元组

tup1 = ('hello', 'world', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
           

1. 修改元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

#以下修改元组元素操作是非法的。
#tup1[0] = 100

#创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
           

1. 删除元组

tup = ('hello', 'world', 1997, 2000)

print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
           

1. 元组内置函数

• tuple(iterable)

  将可迭代系列转换为元组。

• len(tuple)

  计算元组元素个数。

• max(tuple)

  返回元组中元素最大值。

• min(tuple)

  返回元组中元素最小值。

1. 元组是不可变的

   所谓元组的不可变指的是元组所指向的内存中的内容不可变。

6.字典

字典是另一种可变容器模型，且可存储任意类型对象。

1. 创建字典

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
           

1. 访问字典中的值

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
           

1. 修改字典

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

dict['Age'] = 8               # 更新 Age

           

1. 删除字典元素

dict = {'Name': '张三', 'Age': 7, 'Class': 'Six'}

del dict['Name']  # 删除键 'Name'
dict.clear()      # 清空字典
del dict          # 删除字典
           

1. 字典内置函数&方法

• len(dict)

  计算字典元素个数，即键的总数。

• str(dict)

  输出字典，以可打印的字符串表示。

• type(variable)

  返回输入的变量类型，如果变量是字典就返回字典类型。

• radiansdict.clear()

  删除字典内所有元素

• radiansdict.copy()

  返回一个字典的浅复制

• radiansdict.get(key, default=None)

  返回指定键的值，如果键不在字典中返回 default 设置的默认值

• key in dict

  如果键在字典dict里返回true，否则返回false

1. 字典键的特性
   • 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住.
   • 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

7.集合

集合（set）是一个无序的不重复元素序列。

1. 创建集合

   可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) #集合具有去重功能
           

1. 添加元素

   将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

1. 移除元素

   将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

1. 计算集合元素个数

   计算集合 s 元素个数。

1. 清空集合

   清空集合s。

1. 集合内置方法
   • add() 为集合添加元素
   • clear() 清空集合
   • discard() 删除集合中指定的元素
   • pop() 随机移除元素
   • remove() 移除指定元素
   • update() 给集合添加元素

三、语句结构

1.条件控制

1. if语句的一般形式如下所示：

if condition_1:
   执行语句1
elif condition_2:
   执行语句2
else:
   执行语句3
           

1. if嵌套

   在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

if 表达式1:
    语句1
    if 表达式2:
        语句2
    elif 表达式3:
        语句3
    else:
        语句4
elif 表达式4:
    语句5
else:
    语句6
           

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。

2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。

3、在Python中没有switch – case语句。

2.循环语句

1. while循环语句格式如下：

   while 判断条件：
   	 执行语句
              

   需要注意冒号和缩进。另外，在 Python 中没有 do…while 循环。

2. while 循环使用 else 语句

   在 while … else 在条件语句为 false 时执行 else 的语句块。

   语法格式如下：

'''while 条件1:
    语句1
else:
    语句2'''
    count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")
           

1. for语句

   for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

   for循环的一般格式如下：

'''for item in 序列:
   语句1
else:
   语句2''
   list = ['hello','world',1997,2000]
   for item in list:
   	print(item)
           

1. range()函数

   如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

for i in range(5):
   print(i)	# 0 1 2 3 4
for i in range(5,9) :
   print(i)  #5,6,7,8
           

四、输入输出

1.输出

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

#输出方式一
print('hello','world')	#hello	world
#输出方式二
print('{0} and {1}'.format('hello','world') 	hello and world
#输出方式三
age=10
print(f'我的年龄为{age}岁')	#我的年龄为10岁
#输出小数1.234
print('x={:.3f}'.format(1.234)	#1.234
           

2.输入

input可以接收一个表达式作为输入，并将运算结果返回。

str = input("请输入：");
print ("你输入的内容是: ", str)
           

五、函数

1.函数的定义

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的return 相当于返回 None。

  代码示例：

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))
           

2.参数传递

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 传不可变对象实例

def change(a):
   print(id(a))   # 指向的是同一个对象
   a=10
   print(id(a))   # 一个新对象

a=1
change(a)
'''输出结果
140708062561968
140708062561968
140708062562256'''
           

从结果可以看出：形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

• 传可变对象实例

  可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。

# 可写函数说明
def change( list ):
   list.append([1,2,3,4])
   print ("改变后的值: ", list)
   return
 
# 调用changeme函数
mylist = [10,20,30]
change( mylist )
print ("改变前的值: ", mylist)
'''输出结果：
改变后的值:  [10, 20, 30, [1, 2, 3, 4]]
改变前的值:  [10, 20, 30, [1, 2, 3, 4]]
           

3.匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

  实例：

sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
           

六、File(文件) 方法

1.open()方法

open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')
#完整格式为
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
           

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode常用参数值有：

• w： 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
• w+： 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
• a： 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
• a+： 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
• r： 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
• r+： 打开一个文件用于读写。文件指针将会放在文件的开头。

2.file对象

1. file.close()

   关闭文件。关闭后文件不能再进行读写操作。

2. file.read([size])

   从文件读取指定的字节数，如果未给定或为负则读取所有。

3. file.readline([size])

   读取整行，包括 “\n” 字符。

4. file.readlines([sizeint])

   读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

5. file.write(str)

   将字符串写入文件，返回的是写入的字符长度。

6. file.writelines(sequence)

   向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

七、模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

1.import语句

import sys
 
print('命令行参数如下:')
for i in sys.argv:
   print(i)
 
print('\n\nPython 路径为：', sys.path, '\n')
           

1. import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2. sys.argv 是一个包含命令行参数的列表。
3. sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

2.from…import语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

3.from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

八、面向对象

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.类定义

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

class 类名(object):
	语句
           

2.类的属性与方法

1. 类的私有属性

   __private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

2. 类的方法

   在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

3. 类的私有方法

   __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

   实例：

class People(object):
	__sex = '男'	#私有变量
	work = '程序猿'	#公开变量
    def __init__(self, name, age):
        self.name = name      # public
        self.age = age   # private
 
    def who(self):
        print('name  : ', self.name)
        print('sex : ', self.__sex)
        print('work : ', self.work)
        print('age : ', self.age)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        #调用私有方法
        self.__foo()
p = People('张三',28)
p.who()	
p.foo()
p.__foo()
'''运行结果：
name  :  张三
sex :  男
work :  程序猿
age :  28
这是公共方法
这是私有方法
报错
'''
           

3.构造方法

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self): #self代表类的实例，而非类
    self.data = []
           

4.类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('张三',10,30)
p.speak()
           

5.继承

派生类的定义如下所示:

#格式
class DerivedClassName(BaseClassName):

#实例
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    #定义类方法
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #重写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()
           

6.方法重写

class Instrument(object):

    def make_sound(self):
        pass

class Erhu(Instrument):

    def make_sound(self):
        print('二胡在演奏...')

class Violin(Instrument):

    def make_sound(self):
        print('小提琴在演奏...')

class Guitar(Instrument):

    def make_sound(self):
        print('吉他在演奏...')

def play(instrument):
    instrument.make_sound()

if __name__ == '__main__':
    play(Erhu())
    play(Violin())
    play(Guitar())