Python语言语法基础篇

变量

变量几乎是所有编程语言中最基本的组成元素。从根本上说，变量相当于对一块存储数据空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量来使用这块存储空间。

a=10
print(a)
print(type(a))
print(id(a))

print()函数另一个用法，多个值输出

a=10
print(a,type(a))

多个变量赋值

a=b=c=1

a,b,c=1,2,"hello"

标准数据类型

数字

python3支持3种数值类型

(1) 整型，是正或负整数

(2)浮点型，浮点型可以用科学计数法表示

(3)复数，由实数部分和虚数部分构成，可以用a+bj表示，复数的实部a和虚数b可以都是浮点型

x = 123-12j
print(x.real)
print(x.imag)

python3把True和False定义成关键字，但它的值还是1和0，它们可以和数字相加

x=True
y=x+1
print(y)

字符串

三引号将字符串跨越多行。

str = '''
11
22
333
444
'''
print(str)

字符串运算符是*和+，*用于重复输出字符串，+用于连接字符串

print('a'*3)
print('a'+'b')

字符串的格式化

%s	字符串
%f	浮点数
%F	浮点数，与上相同
%d	十进制整数
%c	单个字符
%b	二进制整数
%i	十进制整数
%o	八进制整数
%x	十六进制整数
%e	指数(基底写为e)
%E	指数(基底写为E)
%g	指数(e)或浮点数
%G	指数(E)或浮点数

print('name = %s,age = %d' % ('zhangsan',20))

print('digit = %.4f' % 10.12345)

索引与切片

str = '0123456789'
print(str)
print(str[0])
print(str[0:-1])
print(str[2:5])
print(str[2:])
print(str[0:5:2])

lang = 'python'
print(lang[::-1])

str = "hello"
print(len(str))

str = "abcdef"
print('1' in str)
print('a' in str)
print(max(str))
print(min(str))

字符串格式化

str1 = 'my name is {}'.format("zhangsan")
print(str1)
str2 = 'my name is {0},my age is {1}'.format("lisi",21)
print(str2)

列表

a = [1,2,3,4,5,6]
a[0]=9
a[2:5]=[13,14,15]
print(a)

print([1]*5)
print([5]+[6])

访问列表中的值

list1 = [1,2,3,4,5,6,7]
print("list1[1]:",list1[1])
print("list2[1:5]:",list1[1:5])

列表反转

lang=list('hello')
print(lang[::-1])

更新列表

list1=[1,2,3,4,5,6,7]
list1[1]=10
print(list1)
list1.append(8)
print(list1)

删除列表元素

list1=[1,2,3,4,5,6,7]
del list1[2]
print(list1)

python列表脚本操作符

print([1]*5)
print([5]+[6])

python列表截取与拼接

list=['a','b','c']
print(list[2])
print(list[-2])
print(list[1:])

嵌套列表

a = ['a','b','c']
b = [1,2,3]
x = [a,b]
print(x)
print(x[0])
print(x[0][1])

列表排序

# 升序
ls = [1,4,7,11,5]
ls.sort()
print(ls)
# 降序
ls = [1,4,7,11,5]
ls.sort(reverse=True)
print(ls)
# 列表反转
ls.reverse()
print(ls)

列表转字典

ls = [('a',1),('b',2)]
print(ls)
print(dict(ls))

元组

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

ls = [('a',1),('b',2)]
print(ls)
print(dict(ls))

字典

字典是一种映射类型，用{}标识，是一个无序的key/value对集合

dic1 = {}
dic1['name'] = "wangwu"
dic1['age'] = 21
print(dic1)

dic1 = {'name':'wangwu','age':21}
print(dic1)

遍历字典

dic1 = {'name':'wangwu','age':20}
for idx,val in dic1.items():
    print('idx={0},val={1}'.format(idx,val))

for key in dic1.keys():
    print('key={0},val={1}'.format(key,dic1[key]))

集合

集合是一个无序、不包含重复元素的集。基本功能包括关系测试和删除重复元素

删除重复的元素：

basket = {'a','b','a','b','c','c'}
print(basket)

检测集合的成员：

print('a' in basket)
print('d' in basket)

集合操作：

a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b)
print(a | b)
print(a & b)
print(a ^ b)

行和缩进

Python与其他语言最大的区别就是，Python的代码块不用花括号来控制类、函数及其他逻辑判断，而是使用缩进来实现代码分组

if True:
    print("True")
else:
    print("False")

if True:
    print("True")
else:
  print("False")

运算符和表达式

算术运算符

# 设定变量a为7，变量b为2
a = 7
b = 2
# 两个数相加
print(a + b)
# 两个数相减
print(a - b)
# 两个数相乘
print(a * b)
# 两个数相除
print(a / b)
# 两个数取模
print(a % b)
# 两个数取幂
print(a ** b)
# 两个数取整
print(a // b)

比较运算符

运算符	描述
==	检查两个数是否相等
!=	检查两个数是否不等
>	检查左操作的数是否大于右操作数
<	检查左操作的数是否小于右操作数
>=	检查左操作的数是否大于等于右操作数
<=	检查左操作的数是否小于等于右操作数

a = 10
b = 20
print(a ==b)
print(a != b)
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)

逻辑运算符

运算符	逻辑表达式	描述
and	x and y	x、y都为True，则返回True,否则返回false
or	x or y	x、y任意一个为True，则返回True否则返回false
not	not x	取反

print(3 > 1 and 5 > 1)
print(3 > 1 and 5 < 1)
print(3 > 1 or 5 > 1)
print(3 < 1 or 5 < 1)
print(3 > 1)
print(not (3 > 1))

成员运算符

运算符	描述
in	如果在指定的序列中找到值则返回True，否则返回False
not in	如果在指定序列中没有找到值则返回True，否则返回False

a = 10
b = 20
list = [1,2,3,4,5]

if (a in list):
    print("1 - 变量 a 在给定的列表中list中")
else:
    print("1 - 变量 a 不在给定的列表中list中")

if (b not in list):
    print("2 - 变量 b 不在给定列表中list中")
else:
    print("2 - 变量 b 在给定列表中list中")

a = 2
if (a in list):
    print("3 - 变量 a 在给定列表中list中")
else:
    print("3 - 变量 a 不在给定列表中list中")

条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

循环

while 判断条件:
    语句

n = 10
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
print("1 到 %d 之和为: %d" % (n,sum))

count = 0
while count < 5:
    print(count, "小于5")
    count = count + 1
else:
    print(count, "大于或等于 5")

for语句

languages = {"C","C++","Perl","Python"}
for x in languages:
    print(x,end=' ')

for i in range(5,9):
    print(i , end=' ')

sum = 0
for i in range(1,10):
    sum = sum + i
print('sum=%d' % sum)

data = ['a','b','c','d']
for i in range(len(data)):
    print('index=',i,',data=',data[i])

for i in range(1,10):
    if i % 2 ==0:
        continue
    print('i=',i)

函数

函数的目的是方便重复使用相同的一段代码。

函数的定义

(1) 函数代码块以def关键字开头，后接函数标识符名称和圆括号

(2) 任何传入的参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数

(3) 函数的第一行语句可以选择性的使用文档字符串，用于存放函数说明

(4) 函数内容以冒号起始，并且缩进

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

函数的语法

def 函数名 ( 参数列表 )
函数体

示例1: Python自带的函数

ls = list( range(1,11,1) )
print("max={0},min={1}".format(max(ls),min(ls)))

示例2： 不带参数的函数，使用函数输出hello world

def hello():
    print("hello world")
hello()

示例3： 带参数的函数

def hello(name):
    print("Hello",name)
hello('keynes')

调用函数

def add(x,y):
    print('x={0},y={1}'.format(x,y))
    return x+y
print(add(1,2))

函数也是特殊的对象

def sum(x,y):
    return x+y
add = sum
print(add(6,1))

函数中的文档

def add(x,y):
    """
    这个函数实现加法运算，函数会返回一个加法运算的结果
    :param x:  输入数字参数
    :param y: 输入数字参数
    :return:
    """
    print('x={0},y={1}'.format(x,y))
    return x+y
print(help(add))

默认参数

def printinfo(name,age=25):
    print("名字={0}，年龄={1}".format(name,age))

printinfo(age=20,name="wangwu")
printinfo(name="keynes")

不定长参数

函数用*arg方式接收数据，以元组的形式传参

def func(x,*args):
    print("x={0},args={1}".format(x,args))
    result = x
    for i in args:
        result = result+i
    return  result
print("result=",func(1,2,3))

函数用**kargs方式接收数据，以字典形式传参

def func2(x, ** kargs):
    print('x=',x)
    print('kargs=',kargs)
print(func2(1,a=1,b=2,c=3))

range()函数

range(start,stop[,step])

• start:计数从start开始。默认是0
• stop:计数到end结束，但不包括end。
• step:步长，默认为1

for i in range(5):
    print(i)
for i in range(1,5):
    print(i)
for i in range(0,30,5):
    print(i)
for i in range(0,-5,-1):
    print(i)

x='abcde'
for i in range(len(x)):
    print(x[i])

print(type(range(10)))
print(list(range(10)))

函数作为参数传递

def test(fun,a,b):
    print(fun(a,b))
def func(x,y):
    return 2*x+y
test(func,1,2)

文件

操作文件

file = open(name,mode,encoding=None)

参数说明：

• name: 参数是需要访问的文件名称的字符串，包括文件路径和文件名
• mode: 参数是打开文件的模式
• encoding: 参数是打开文件的编码方式

文件的打开模式

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

file对象主要方法说明：

• file.read([size]): 读取文件的全部内容，如果指定size参数，每次最多读取size字节的内容
• file.readline(): 读取文件的一行内容
• file.readlins([size]): 读取文件的全部行，以列表形式返回。如果指定size参数，读取包含size行的列表
• file.write(str): 在文件中写入字符串，如果要写入字符串以外的数据，需要把数据转换为字符串
• file.close(): 关闭文件，释放资源

读取文件

file=open('f:/test/test.txt','r',encoding='utf-8')
data=file.read()
print(data)
file.close()

file=open('f:/test/test.txt','r',encoding='utf-8')
for line in file.readlines():
    print(line.strip())
file.close()

file=open('f:/test/test.txt','r',encoding='utf-8')
for line in file:
    print(line.strip())
file.close()

写入文件

file=open('f:/test/test.txt','w',encoding='utf-8')
file.write('aaa\n')
file.close()

file=open('f:/test/test.txt','a',encoding='utf-8')
file.write('aaa\n')
file.close()

二进制文件

读写完成了一次复制动作

file = open("C:/test/test.png",'rb')
content=file.read()
file.close()

file2 = open("C:/test/test2.png","wb")
file2.write(content)
file2.close()

为了避免内存溢出，对过大文件进行优化

import os
fileTotalSize = os.stat('C:/test/test.png').st_size
print("fileTotalSize={0}".format(fileTotalSize))
readSize=0
file=open('C:/test/test.png','rb')
file2=open('C:/test/test2.png','wb')

while readSize<fileTotalSize:
    # 每次读取50kb的文件内容
    content=file.read(1024*50)
    readSize=readSize+len(content)
    file2.write(content)
else:
    print("fileTotalSize={0},readSize={1}".format(fileTotalSize,readSize))

file.close()
file2.close()

使用with语句

在执行file.read()从文件中读取数据时，有可能产生IOError异常。一旦出错，后面的file.close()就不会执行，所以为了保证无论是否出错都能正常关闭文件，可以使用try…finally

try:
    file=open('C:/test/test.txt','r',encoding="utf-8")
    data=file.read()
finally:
    if file:
        file.close()

这段代码虽好，但是太长了，python引入with语句自动执行file.close()

with open('C:/test/test.txt','r',encoding='utf-8') as file:
    data=file.read()

with open('C:/test/test.txt','a',encoding='utf-8') as file:
    file.write('aaa')

with open('C:/test/test.txt','r',encoding='utf-8') as file:
    print(file.read())
    print('rows:%d' % len(file.readlines()))

with open('C:/test/test.txt','r',encoding='utf-8') as file:
    for content in file.readlines():
        print(content.strip())

电子表格

从csv文件中读取数据

import csv
with open('C:/test/test.csv','r',encoding='utf-8') as file:
    reader=csv.reader(file)
    for row in reader:
        print(row)

写到csv文件

import csv
with open('C:/test/test2.csv','w',newline='') as file:
    writer=csv.writer(file)
    writer.writerow(['a','b','c'])
    writer.writerow([1,2,3])
    writer.writerow([4,5,6])

面向对象

类与对象的定义

定义类

class Car(object):
    num=111
    def info(self):
        print("This is a car")

car=Car()
print("Car类对象的属性num为：",car.num)

构造方法

Python中类的构造方法函数是__init__()，一般用来为类的属性设置初值或进行其他必要的初始化工作，在创建对象时被自动调用和执行。如果用户没有设计构造函数，Python将提供一个默认的构造函数进行必要的初始化工作。init()方法的第一个参数是self，表示创建的实例本身。

class People(object):
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender

    def speak(self):
        """ people can speak"""
        print('{0}的性别是{1}'.format(self.name,self.gender))

people = People("Tom","Male")
people.speak()

people.name="Jim"
people.gender="female"
print("name={0}.gender={1}".format(people.name,people.gender))

私有属性和方法

class Student(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def info(self):
        print("name={0},age={1}".format(self.name,self.age))
stu=Student("Tom",21)
stu.name="Jim"
stu.age=25
print("name={0},age={1}".format(stu.name,stu.age))

修改Student类把属性name和age改为私有属性

class Student(object):
    def __init__(self,name,age):
        self.__name=name
        self.__age=age

    def info(self):
        print("name={0},age={1}".format(self.__name,self.__age))
stu=Student("Tom",21)
stu.info()

在类中定义私有方法

class Student(object):
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def __printFun(self):
        print("name={0},age={1}".format(self.__name, self.__age))
    def info(self):
        self.__printFun()
stu=Student("Tom",21)

继承

单继承

class People(object):
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def speak(self):
        print('{0}的性别是{1}'.format(self.name,self.gender))

class Student(People):
    def __init__(self,name,gender,grade):
        super(Student,self).__init__(name,gender)
        self.grade=grade
    def info(self):
        print('{0}说：我的性别是{1},在读{2}年级'.format(self.name,self.gender,self.grade))

stu=Student('Tom','male',3)
stu.speak()
stu.info()

子类对父类方法的重写

class People(object):
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def speak(self):
        print('{0}的性别是{1}'.format(self.name,self.gender))

class Student(People):
    def __init__(self,name,gender,grade):
        People.__init__(self,name,gender)
        self.grade=grade
    def speak(self):
        super().speak()
        print('{0}说：我的性别是{1}，在读{2}年级'.format(self.name,self.gender,self.grade))

stu=Student('Tom','male',3)
stu.speak()

多继承

class Animal1:
    def __init__(self):
        print("creating an animal1")
    def run(self):
        print("running ...")
    def jump(self):
        print("jump from Animal1")
class Animal2:
    def __init__(self):
        print("creating an Animal2")
    def eat(self):
        print("eating ...")
    def jump(self):
        print("jump from Animal2")
class Pig(Animal1,Animal2):
    def __init__(self):
        print("creating a pig")
    def cry(self):
        print("crying ...")

pig=Pig()
pig.cry()
pig.eat()
pig.jump()

多继承从左至右的顺序，先在Animal1中寻找，再到Animal2中寻找

静态方法

class Car(object):
    @staticmethod
    def description():
        print("This is a car")

c1=Car()
c1.description()
Car.description()

魔法方法和特殊属性

dict

__dict__可以访问类的所有属性，以字典的形式返回

class People(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age

people=People('Tom',22)
print(people.__dict__)
print('name=',people.__dict__['name'])
print('age=',people.__dict__['age'])

slots

__slots__内置属性，可以把实例属性锁定到__slots__规定的范围内

class Student(object):
    __slots__=("name","age")
    def __init__(self,name,age):
        self.name=name
        self.age=age
stu=Student("Tom",25)
print("stu name={0},age={1}".format(stu.name,stu.age))
stu.age=90

可调用对象

在Python中，函数也是一种对象。实际上，任何一个有__call__()特殊方法的对象都被当作是函数

class Add(object):
    def __call__(self, a):
        return a+5
add = Add()
print(add(2))

class Person(object):
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def __call__(self, friend):
        print('打印类的实例属性name={0},gender={1}'.format(self.name,self.gender))
        print('打印__call__()方法的参数 friend={0}'.format(friend))
person=Person('Tom','male')
person('Jim')

错误和异常

错误

inp = input("input a int param:")
num=int(inp)
print(num)

input a int param:aaa

Traceback (most recent call last):

  File "C:\Users\许盛\PycharmProjects\pythonProject1\test\__init__.py", line 2, in <module>

    num=int(inp)

        ~~~^^^^^

ValueError: invalid literal for int() with base 10: 'aaa'

异常

python中常见的异常类

异常	描述	引起异常的代码（例）
Exception	所有异常的基类
ZeroDivisionError	除数为0	print(1/0)
TypeError	传入对象类型与要求的不符合	print(2+‘2’)
NameError	尝试访问一个没有声明的变量	plain a = 1 del a print(a)
IndexError	索引超出序列范围	plain a=[1,2,3] print(a[3])
KeyError	请求一个不存在的字典关键字	plain dic = {'name':'wangwu'} print(dic['age'])
ValueError	传给函数的参数类型不正确，如给int()函数传入字符串	plain num=input('input a int param') int(num)
AttributeError	尝试访问未知的对象属性	plain class People(object): name='wangwu' p=People() print(p.age)

处理异常

语法：

try:

pass

except 异常类型 as ex:

pass

try:

主代码块

pass

except 异常类型 as e:

异常时，执行该块

pass

else:

主代码执行完执行该块

pass

finally:

无论异常与否，最终执行该块

pass

try:
    inp = input("input a int param:")
    num = int(inp)
    print(num)
except ValueError as e:
    print("抛出异常")
    print(e)

如果捕获异常时不想指定异常，想直接捕捉所有类型的异常就是用Exception

try:
    inp = input("input a int param:")
    num = int(inp)
    print(num)
except Exception as e:
    print("抛出异常")
    print(e)

异常的分类处理

try:
    x = int(input('input x:'))
    y = int(input('input y:'))
    print('x/y =',x/y)
except ZeroDivisionError: # 捕捉除0异常
    print("ZeroDivision")
except (TypeError,ValueError) as e: # 捕捉多个异常
    print(e)
except: # 捕捉其他异常
    print("it's still wrong")
else:
    print("it work well")

自定义异常

在python中所有异常的基类是Exception，所以异常处理的类需要继承Exception。错误处理的类中写一个特殊的类成员__str__。用此以后，创建的使用print打印的内容就会是__str__返回值返回的内容。

class MyException(Exception):
    def __init__(self,message):
        self.message=message

    def __str__(self):
        return self.message

try:
    a = 6
    b = 4
    if a > b:
        raise MyException("自定义异常")
except MyException as err:
    print("打印MyException异常",err)
except Exception as err:
    print("打印Exception异常",err)

模块

import语句

import module1[,module2[,...moduleN]]

import math
print(pow(3,2))

:::info
import ModuleName as shortName

:::

import pandas as pd

from…import语句

在python中一个后缀为.py的文件就是一个模块

def hello():
    print("hello")

在同级目录下

from pm import hello
hello()

from…import * 语句

一次性导入模块下所有函数

from math import *
data1 = pow(3,2)
data2=sqrt(data1)

模块的__name__属性

def sayHello():
    print("hello python")
if __name__ == "__main__":
    print("This is main of module hello")
    sayHello()

包

一个包由多个模块组成，即有多个.py的文件，这个包就是一个有层次的文件目录结构。

在aaa包下建立pm1.py

lang = 'python'

def sayHello():
    print('hello '+lang)

调用

import aaa.pm1 as pm
pm.sayHello()
print('调用模块的变量 pm.lang={}'.format(pm.lang))

常用模块

os模块

os.popen()方法

可以运行os层的命令

import os
import time
while True:
    data = os.popen('docker ps').read()
    print(data)
    time.sleep(5)

os.listdir()方法

os.listdir()方法用于返回指定的文件夹包含的文件和目录的名称列表。

import os
dirs=os.listdir("c:/")
print(dirs)

time模块

获取当前时间戳

import time
ticks=time.time();
print('当前时间戳为:',ticks)

获取当前时间

import time
print('获得当前时间=',time.ctime())

格式化日期

import time
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

python中时间日期格式化符号：

• %y:两位数年份
• %Y:四位数年份
• %m:月份
• %d:月内中的一天
• %H:24小时制小时
• %I:12小时制小时
• %M:分钟
• %S:秒

推迟线程的运行

import time
print("开始时间：{0}".format(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())))
time.sleep(5)
print("结束时间：{0}".format(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())))