Python基础知识学习与回顾

Python学习

Python基本语法

标识符

标识符由数字、字符串、下划线构成。

注意事项：

1. 标识符不以数字开头
2. 区分大小写
3. 下划线开头的标识符具有特殊意义
4. 保留字，Python保留了一些关键字，这些关键字都是通过小写字母进行保存。

下划线开头的特殊含义：

单下划线： _foo 代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。 

双下划线： __foo 代表类的私有成员 

双下划线开头和结尾： __foo__  Python里特殊方法专用的标识，如 __init__() 代表类的构造函数。 

行与缩进

python不通过括号来保留层级关系，通过缩进进行编写模块。缩进的数量可以自己控制，但是需要统一。

多行语句

使用斜杠\可以把一行语句当做多行来显示

# 去掉斜杠会报错
total = one + \         
		two + \         
		three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符：

# 不用斜杠也不会报错
data = {
    
    1,2,3,         
		4,5,6}  
		
data1 = [1,2,3,          
		4,5,6] 
		
data2 = (1,2,3,          
		4,5,6)
		

引号

引号可以用来定义字符串，可以是单引号，双引号和三引号。单引号和双引号之间没有区别，三引号可以用来定义多行的字符串，同时三引号也可以用来表示多行的注释。

Python 变量

变量可以存储内存中的值。创建变量可以在内存中开辟空间。变量可以存储整数、小数或者字符。

每个变量在使用前必须赋值，变量被赋值之后，这个变量才会被创建。

变量等过=号被赋值

Python标准数据类型

• 数字 Numbers

  • int 符号整数
  • long 长整型
  • float 浮点型
  • complex 复数

• 字符串 String

  • 字符串取值的两种顺序

  • 从左到右索引默认从0开始，从右到左索引默认从-1开始。

  • 

  • str = 'Hello World!'   
    print str           # 输出完整字符串 
    print str[0]        # 输出字符串中的第一个字符 
    print str[2:5]      # 输出字符串中第三个至第六个之间的字符串 print str[2:]       # 输出从第三个字符开始的字符串 
    print str * 2       # 输出字符串两次 
    print str + "TEST"  # 输出连接的字符串
    
    #python列表截取可以接收三个参数，第一个是起始下标，第二个是终止下标，第三个是截取的步长
    
    print str[1:4:2]
    #意思就是从索引1到索引4设置为步长为2，取出这些字符
    
    

• 列表 List

  • 是Python中使用最频繁的数据类型

  • 里面的数据类型可以多样，可以包含数字、字符串和字符，也可以包含列表进行嵌套

  • 采用[]进行标识

  • 列表的基本操作

    #列表的基本操作 
    list = ['aad',76,'c',23.1,'e','f'] 
    newlist = [123,'sow'] 
    print(list[1:]) 
    print(list[:4]) 
    print(list[1:3]) 
    print(list[1:5:2]) 
    print(list+newlist)
    
    #一些基本的函数 
    list1 = [1,2,3,4,5,6] 
    list1.append(7)         #列表末尾添加元素 
    list1.count(1)          #统计某个元素出现的次数 
    list1.sort()            #对列表进行排序 
    list1.reverse()         #反转列表 
    list1.pop()             #弹出第一个元素，并返回该值 
    list1.index(4)          #找到元素4的下标 
    list1.extend([8,9,10])  #末尾添加列表
    

• 元组 Tuple

  • 类似于列表，但是里面的元素不能二次赋值，不能更新，相当于只读列表

  #元组的基本操作 
  tuple1 = ('aad',76,'c',23.1,'e','f') 
  newtuple = (123,'sow') 
  print(tuple1[:]) 
  print(tuple1[1:]) 
  print(tuple1[1:3]) 
  print(tuple1*2) 
  print(tuple1 + newtuple)
  
  #元组的一些基本函数
  #元组里面的元素不能修改，但是可以对元组进行连接和组合
  tup3 = tuple1 + newtuple		#元组的组合
  del tup3						#元组的删除
  len(tuple1)                     #元组长度
  max(tuple1)                     #求元组中的最大值
  

• 字典 Dictionary

  • 除列表以外最灵活的数据结构类型，列表是有序的对象集合，字典是无序的对象集合。字典当中的元素是通过键来存取的，而不是通过偏移存取。

  #字典 dict = {} 
  dict['one'] = "first" 
  dict['two'] = 'second' 
  newdict = {
        
        'name':'Phil','number':2023, 'school': 'jLU'} print(dict['one']) 
  print(dict['two']) 
  print(dict) 
  print(dict.keys()) 
  print(dict.values())
  

  三类数据类型对比：

  数据类型	表示符号	特点
  列表 List	[]	1、最灵活 2、元素可以进行多样，可以进行增删改查 3、用下标进行取值
  元组 Tuple	()	1、最不灵活 2、元素可以多样，创建之后不能对里面元素进行操作 3、用下标进行取值
  字典 Dictionary	{}	1、灵活度仅限于列表 2、元素可以多样，可以进行增删改查 3、用键值对进行取值

  数据类型转换

  python里面可以拥有内置函数进行格式转化。这些函数可以返回一个新的对象

  #数据类型转化 
  number = 12.5 
  count = 5 
  string = "1,2,3,4,5" 
  print(int(number))      #转化为整数 
  print(complex(number))  #转化为复试 
  print(str(number))      #转换为字符串 
  print(list(string))     #转化为列表 
  print(tuple(string))    #转化为元组 
  print(dict(string))     #转化为字典,因为不是（key,value)元组，会报错 
  print(set(string))      #转化为集合 
  print(hex(count))       #转化为16进制的字符串 
  print(oct(count))       #转化为8进制的字符串
  

  Python运算符

  算数运算符应该都接触过，加减乘数，还有一些稍微特别一些的，取模和幂和整除。

  比较运算符，就是常见的大于、等于、小于这些，其中不等于需要注意下

  赋值运算符，=，还有一些简写的，-=，+=这些

  位运算符，这个一般很少用，但是这个是比较底层的元素，可以提高运算速率

  逻辑运算符，and,or,not就相当于与，或，非运算

  成员运算符，in，not in,判断指定的序列是否存在某个值

  +，-，*，/，%，**	加减乘除，取模，幂次
  //	取整数，返回商的整数部分（向下取整）
  ==	等于号，判断两个数是否相等
  ！=	不等于，判断两个数是否不相等
  >,<,>=,<=	大于、小于、大于等于、小于等于
  **=,//=	c**=a 等于 c=c**a
  &	按位与运算，都为1，才为1，否则为0
  |	按位或运算，只要其中一个为1，才为1，否则为0
  ^	异或运算，二进制对应的位置相异时，结果为1
  ~	取反运算，把0变成1，把1变成0
  >>	右移运算，二进制全部右移若干位
  <<	左移运算，高位丢弃，低位补0

Python 条件语句、循环语句

各种编程语言其实都类似，稍微记下语法的区别就可以

#if else基本使用
"""
if 判断条件:
	执行语句.....
else:
	执行语句.....	
"""

#循环语句 分为while循环和for循环

"""
while 循环
while 判断条件：
	执行语句
"""

#举例
a = 1
while a < 10:
    a+=2
    
"""
for循环
for 变量 in 序列（可以是列表，字符串）:
	
"""

循环控制语句：

break	终止循环，跳出整个循环
continue	终止循环，跳出该次循环，执行下一次循环
pass	空语句，保证程序结构的完整性

Python日期和时间

Python提供了time和calendar两个模块用于格式化日期和时间。

每个时间戳是从1970年1月1日午夜经历了多长时间来进行表示的。

#时间
print(time.time())                      #输出时间戳
print(time.localtime(time.time()))      #输出本地时间
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))      #格式化日期
#格式化需要注意，大小写%Y,%y以及很多表示的内容都是不一样的，需要根据需求设置对应的格式，具体看官网

#日历
print(calendar.calendar(2023))			#输出2023年的日历
print(calendar.month(2016,1))			#输出2016年的1月份日历

Python函数

函数是组织好的，可重复使用，用来实现单一，或相关联功能的代码段。

作用：提高应用的模块性和代码的重复利用率。

定义函数，函数调用

• **def**开头，后面接函数名和圆括号(),圆括号里面放参数
• 函数内容从冒号开始，然后要进行缩进
• return表示结束函数，不带return返回none

#print函数 
def printstr(str):         
    print(str)         
    return 
#函数调用 
printstr("this is a test")

参数传递

在Python中，类型属于对象，变量没有类型。

Python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

• 不可变类型：数字、字符串、元组
  • a=5,改成了a=10。并不是改变了a，而是生成了一个新的对象10，丢弃原来的5，新生成了一个a
  • 在python中参数传递中，只是传递了值，不会影响原本的对象，类似于c的值传递
• 可变类型：列表、字典
  • la=[1,2,3,4],la[1]=10,更改了元素，本身la并没有变，只是内部的值变化了。
  • 在python中可变类型的参数传递类似于C语言的指针。

参数

• 必备参数：调用时的数量必须与声明时的一样。

#print函数 
def printstr(str):         
    print(str)         
    return 
#必备参数
printstr("this is a test")

• 关键字参数：关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#print函数  
def printstr(name,age):              
	print(name+age)              
    return  
#关键字参数 
printstr(age="18",name="Yang")  #顺序可以调换

• 默认参数:调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age

#print函数  
def printstr(name,age=18):    #age设置了默认值              
    print(name+age)                  
    return  
#默认参数 
printstr(name="Yang")

• 不定长参数：函数能处理比当初声明时更多的参数。加了星号（*）的变量名会存放所有未命名的变量参数。

# 可写函数说明 
def printinfo( arg1, *vartuple ):    
    "打印任何传入的参数"    
    print "输出: "    
    print arg1    
    for var in vartuple:       
        print var
        return   
# 调用printinfo 函数 
printinfo( 10 ) 
printinfo( 70, 60, 50 )

局部变量和全局变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

Python模块

Module Python文件，包含Python的对象定义和Python的语句。

可以有逻辑的组织代码段

让代码更好用，更易懂

可以定义函数、类和变量，可以包含可执行的代码。

模块导入 import

import module		         #引入模块
from modnmae import name1    #从模块中导入一个制定的部分
from modname import * 		 #把一个模块的所有内容全部导入

搜索路径

导入模块，Python解析器对模块位置的搜索顺序;

1. 当前目录
2. 不在当前目录，搜索shell变量的PYTHONPATH下的目录
3. 如果都找不到，Python会查看默认路径

Python中的包

分层次的文件目录结构，由模块以及子包构成。

包就类似于文件夹，文件夹中必然存在__init__..py文件，这个文件的内容可以是空的，只是用来标识当前文件夹是一个包。

让代码更好用，更易懂

可以定义函数、类和变量，可以包含可执行的代码。

Python异常处理

Python异常

异常就是程序无法正常执行。异常有很多种类型，我们如果希望发生异常时不要中断程序，这时候就需要用到异常处理，否则程序就会终止执行。

异常处理

使用try/except语句

try：
	<语句>    #可能会出现异常的地方
except <名字>:
	<语句>	  #try部分发生了name异常
except<名字>,<数据>:
	<语句>	 #引发了name异常，获得附加的数据
else:
	<语句>	#没有异常发生

程序处理的流程：

• try发生了异常，Python控制流找到第一个匹配该异常的except的语句，异常处理完之后，控制流就通过了整个try语句
• 如果try语句发生了异常，却没有匹配上的except语句，异常就会递交到上层的try，或者到程序的最上层，这样就会结束程序，打印出默认的出错信息。
• try没有发生异常，python控制流将会执行else语句后的语句。然后通过整个try语句。

使用try/finally语句

无论语句是否发生异常都会执行最后finally的代码。
使用 raise语句
raise语句可以触发异常

Python面向对象

Python一开始设计就是面向对象的语言。
面向对象就是，解决同一个问题 ，面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题，面向对象是以功能来划分问题，而不是步骤。

面向对象的三大特征：

• 封装

  • 把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

• 继承

  • 继承，指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。

• 多态

  • 多态，是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

面向对象技术简介

• 类（class）:具有相同属性和方法的对象的集合。对象是类的实例。
• 类变量：类的变量在整个是厉害的对象中是公共的。类变量通常不作为实例变量使用。类变量定义在类中且在函数体之外。
• 数据成员：类变量或者实例变量。用于处理类以及实例对象相关的数据。
• 方法重写：从父类继承的方法不能满足子类的需求，对其进行改写。
• 局部变量：定义在方中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来进行表示的，变量就称为实例变量，在类声明的内部，但是是在类的其他成员方法之外声明的。
• 继承：派生类继承基类的字段和方法。
• 实例化：创建类的实例
• 方法：类中定义的函数
• 对象：类定义的数据结构实例。对象发阔两个数据成员（类变量和实例变量）和方法。

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
_init_()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法