复习一下很久没用的Python

1 变量

1.1 变量的定义

在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值

变量名 = 值

python中#是注释。

# 定义变量---学生学号
studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
print(studentNo)       
print(stuentPassword)
#是代码注释，快捷键是Ctrl+/

Python的代码缩进

Python语言通过缩进来组织代码块，这是Python的强制要求。下面的代码有误：

# 定义变量---学生学号
    studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
print(studentNo)
print(stuentPassword)

和其他编程语言不同，Python代码对格式要求非常严格。代码写的里出外进，无法通过编译。后面我们在分支，循环，函数，类等知识点时还会多次看到这种情况。

1.2 变量的类型

变量的四要素：

变量的名称
变量保存的数据
变量存储数据的类型
变量的内存地址（标识）

在 Python 中定义变量时需要指定类型吗？

不需要

Python 可以根据 = 等号右侧的值，自动推导出变量中存储数据的类型

数据类型可以分为 数字型 和 非数字型

数字型

整型 (int)
浮点型（float）
布尔型（bool）
真 True 非 0 数 —— 非零即真
假 False 0

非数字型

字符串
列表
元组
字典

使用 type 函数可以查看一个变量的类型

type(name)

i = 10
f = 10.5
b = True

print(i+f+b)

发生了自动类型转换，全部转换成了浮点数。

21.5

字符串变量之间使用 + 拼接字符串

在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

first_name = "三"
last_name = "张"
print(first_name + last_name)

字符串变量可以和整数使用 * 重复拼接相同的字符串

print("-" * 50)

 '--------------------------------------------------'

数字型变量和字符串之间不能进行其他计算

first_name = "zhang"
x = 10

print( x + first_name)
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
类型错误：`+` 不支持的操作类型：`int` 和 `str`

解决办法：使用str(x)将x的类型强制转换成字符串类型

first_name = "zhang"
x = 10
print(str(x)+first_name)

1.3 变量的输入

在 Python 中，如果要获取用户在键盘上的输入信息，需要使用到 input 函数

在 Python 中可以使用 input 函数从键盘等待用户的输入

用户输入的任何内容 Python 都认为是一个 字符串

字符串变量 = input("提示信息：")

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")

# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")

# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)

# 2> 将苹果重量转换成小数
weight = float(weight_str)

# 3> 计算付款金额
money = price * weight

print(money)

1.4 变量的输出

在 Python 中可以使用 print 函数将信息输出到控制台

print("我的名字叫 %s，请多多关照！" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))

2 条件语句

Python 中，if 语句的基本形式如下：

if 判断条件：
    执行语句……
else：
    执行语句……

results=59

if results>=60:
    print ('及格')
else :
    print ('不及格')

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

# -*-coding:utf-8-*-

results = 89

if results > 90:
    print('优秀')
elif results > 80:
    print('良好')
elif results > 60:
    print ('及格')
else :
    print ('不及格')

if 语句多个条件同时判断

# -*-coding:utf-8-*-

java = 86
python = 68

if java > 80 and  python > 80:
    print('优秀')
else :
    print('不优秀')

注意：if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于 >（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

java = 86
python = 68

if (80 <= java < 90) or (80 <= python < 90):
    print('良好')

3 循环语句

Python 提供了 for 循环和 while 循环，当然还有一些控制循环的语句：

3.1 while语句

while 循环条件:
    执行语句

count = 1
sum = 0
while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

当然 while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于跳出本层循环

比如，上面的例子是计算 1 到 100 所有整数的和，当我们需要判断 sum 大于 1000 的时候，不在相加时，可以用到 break ，退出整个循环

count = 1
sum = 0
while  count <= 100:
    sum = sum + count
    if  sum > 1000:  #当 sum 大于 1000 的时候退出循环
        break
    count = count + 1
print(sum)

3.2 for语句

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

基本的语法格式：

for iterating_var in sequence:
   statements(s)

示例：

for letter in 'www.neuedu.com':
    print(letter)

Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range()来打印一系列的数字：

for value in range(1,5):
    print(value)

述代码好像应该打印数字1~5，但实际上它不会打印数字5：

要打印数字1~5，需要使用range(1,6)：

for value in range(1,6):
    print(value)

4 列表

4.1 列表定义 list

就像Go里的slice一样。但数据类型可混用

例如：

[1,2,3,2.4,5]
[0.01,"zhangsan",[1,2,3]]

创建

使用“=”直接将一个列表赋值给变量即可创建列表对象。

使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

例如：a_list = list(“Hello”) 将字符串 “hello” 转换成列表 [‘H’，‘e’，‘l’，‘l’，‘o’]

删除

当不再使用时，使用del命令删除整个列表例如：

x =[1,2,3]

del x[1]                    #删除指定位置元素

del x                        #删除整个列表

4.2 列表元素的增加

（1）append()

向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。例如：

x = [1,2,3]

x.append(4)

（2）insert()

向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。

x = [1,3,4]
x.insert(1,2)

>>>x
[1,2,3,4]

（3）extend()

将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。

x = [1,2]

x.extend([3,4])

>>>x
[1,2,3,4]

（4）运算符 + 和 *

并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。

x = [1,2,3]
y = x + [4]
>>>y
[1,2,3,4]

y = x * 2
>>>y
[1,2,3,4,1,2,3,4]

列表里面的+和*，不是对里面的数操作。

4.3 列表元素的删除

（1）pop()

使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常。

>>>x = [1,2,3,4]
>>>x.pop()                        #弹出并返回尾部元素
4

>>>x.pop(1)                     #弹出并返回指定位置的元素
>>>2

（2）remove()

删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

>>>x = [1,2,2,3,4]

>>>x.remove(2)

>>>x

[1,2,3,4]

（3）clear()

清空列表。

>>>x = [1,2,3,4]

>>>x.clear()

>>>x

[ ]

（4）del()

删除列表中的指定位置上的元素。

>>>x = [1,2,3,4]

>>>del x[1]

>>>x

[1,3,4]

4.4 列表元素访问与计数

（1）count()

统计指定元素在列表对象中出现的次数。

>>> x =[1,2,3,3,4,5]
>>>x.count(3)
2

>>>x.count(0)
0

（2）index()

获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。

>>>x = [1,2,3,2,2,4]
>>>x.index(2)

1

（3）in

测试列表中是否存在某元素

>>>x = [1,2,3,4]

>>>3 in x

True

>>>5 in x

False

4.5 列表排序

（1）sort()

按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> import random

>>> random.shuffle(aList)                              #随机降序

>>> aList

[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]

>>> aList.sort()                                              #默认是升序排序

>>> aList.sort(reverse = True)                       #降序排序

>>> aList

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

（2）reverse()

序列反转

>>>x = [1,3,2,4,6,5]

>>>x.reverse()

>>>x

[5,6,4,2,3,1]

（3）sorted()

sorted是内置函数，对列表进行排序并且返回新的列表，而不对原列表进行修改。

>>>x = [6,4,2,4,1]

>>> sorted(x)                                     #升序排序

[1,2,4,4,6]

>>> sorted(aList,reverse = True)             #降序排序

[6,4,4,2,1]

>>>x

[6,4,2,4,1]

（4）reversed

也是内置的函数，返回一个序列反转的，而不对原列表做任何修改

>>>x =[1,5,3,6,2]

>>>list(reversed(x))

[2,6,3,5,1]

>>>x

[1,5,3,6,2]

4.6 用于列表操作的常用内置函数

（1）len()

返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。

（2）max()、min()

（3）sum()

对列表的元素进行求和运算。

（4）enumerate()

枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

>>> for item in enumerate('abcdef'):
print(item)
(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

(5, 'f')

4.7 遍历列表的三种方式

a = ['a','b','c','d','e','f']

for i in a:
    print(i)

for i in range(len(a)):
    print(i,a[i])
    
for i,ele in enumerate(a):
    print(i,ele)

5 元组 tuple

元组 tuple 属于不可变序列（元素集合），一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。

5.1 元组的创建与删除

>>>x = (1,2,3)

创建空元组的方法

>>>x = ()                                       
>>>x = tuple()

使用tuple函数将其他序列转换为元组

>>>tuple(range(5))                   

(0,1,2,3,4)

>>> tuple('abcdefg')                          #把字符串转换为元组

('a', 'b', 'c', 'd', 'e', 'f', 'g')

>>> aList

[-1, -4, 6, 7.5, -2.3, 9, -11]

>>> tuple(aList)                                #把列表转换为元组

(-1, -4, 6, 7.5, -2.3, 9, -11)

删除

使用del可以删除元组对象，不能删除元组中的元素

5.2元组与列表的区别

1.元组中的数据一旦定义就不允许更改。

2.元组没有append()、extend()和insert()等方法，无法向元组中添加元素。

3.元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。

4.从效果上看，tuple( )冻结列表，而list( )融化元组。

5.3 元组的优点

1.元组的速度比列表更快。

2.元组对不需要改变的数据进行“写保护”将使得代码更加安全。

3.元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。

6 集合 set

Set（集合）数据类型它和Tuple、List一样都属于复合数据类型，而且集合数据类型是一种无序不重复元素的序列

在Python中，我们可以使用大括号｛｝或内置函数Set()来创建一个集合(创建一个空集合必须用Set()函数，不可用｛｝，因为｛｝实质是创建一个空的字典。

a = {'a','b','c','d','a'}#创建集合a
print(a)#因为集合是无序不重复元素序列，所以不会输出多出的a
b = set('sdgsdggfdgdasrfdsf')#运用Set()函数创建集合b
print(b)

在集合中，我们可以使用关键字add或update来添加新的元素

b = set('hgdhsdfsghdvhgsfs')
print(b)
b.add('fuck')
b.update('good')
print(b)

{'h', 'g', 'f', 's', 'v', 'd'}
{'h', 'fuck', 'g', 'f', 's', 'v', 'o', 'd'}

当然，如果想要删除某些元素，可以使用关键字remove，discard或pop(pop会随机删除某些元素)

b = set('abcdefghijk,fuck,abats')
print(b)
b.remove('f')
print(b)
b.discard('h')
print(b)
b.pop()
print(b)

集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：

print(a - b)
print(a | b)
print(a & b)
print(a ^ b)

7 字典 dictionary

字典就是一个关联数组或散列表（映射，键值对），而且可以存储任何数据类型的数据值对象

创建一个空字典需要用大括号｛｝，在字典中每一个值对用冒号，且每个值需要逗号 , 分隔。

a = {
    'a':'Python',
    'b':'347',
    'c':'hjgjhfgy'
}#创建一个字典

b = {'a':'HTML/Javascript',
     'b':'Rust'
    }

print(b)
print(a['a'],a['c'])

{'a': 'HTML/Javascript', 'b': 'Rust'}
Python hjgjhfgy

想要修改字典内的数据很简单，与前面的复合数据类型修改方式一样，不过要注意字典修改数据时修改对象填的不是数字，而是对应的名称。

a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
b = {'a':'HTML/Javascript','b':'Rust'}
print(b)
print(a['a'],a['c'])
a['c']='Perl'
print(a['a'],a['c'])


{'a': 'HTML/Javascript', 'b': 'Rust'}
Python hjgjhfgy
Python Perl

清除字典数据也很简单，与集合一样，使用clear()函数，然而删除的话就需要用到del语句

a = {'a':'Python','b':'347','c':'hjgjhfgy'}#创建一个字典
print(a)
a.clear()#清除字典所有数据
print(a)
del a#删除字典
print(a)

{'a': 'Python', 'b': '347', 'c': 'hjgjhfgy'}
{}
NameError: name 'a' is not defined #删除了字典，显示错误

8 函数

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

函数能提高应用的模块性，和代码的重复利用率。

8.1 Python函数定义

def functionname(parameters):

   "函数_文档字符串"

   function_suite

   return [expression]

def remainder(a,b):
  q = a // b
  r = a - q * b
  return r

8.2 不定长参数

当不确定会传入参数的个数时，可以对可以不输入的参数名前面加“*”号，按顺序输入时进行对应即可。

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

9 模块

Python 模块(Module)，是一个Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

（1）import导入

import support   # 导入模块，并不导入单个函数

# 现在可以调用模块里包含的函数了，但是必须通过模块名.函数名的方式调用

support.print_func("Runoob")

（2）from...import导入

下面的语句可以将模块中的某一部分导入，它只会将里这个部分单个引入到执行这个声明的模块的全局符号表。这个部分可以是某个函数块，也可以是函数块的子函数块。

from modname import name1[, name2[, ... nameN]]

（3）from...import*导入

前两种语句都是导入模块的部分，只是部分导入的位置不同，而使用From …import*则是导入模块的全部项目，尽量少用，太耗内存。

10 Python面向对象

10.1 创建类

'所有员工的基类'
class Employee:
    empCount = 0
    def __init__(self, name, salary): #构造函数
        self.name = name            # 添加实例属性
        self.salary = salary        # 添加实例属性
        Employee.empCount += 1      # 修改类属性
    def displayCount(self):         # 添加实例方法
        print("TotalEmployee %d" % Employee.empCount) # 读取类属性
 
    def displayEmployee(self):      # 添加实例方法
        print("Name:", self.name, ", Salary:", self.salary) # 读取实例属性

empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount访问。

第一种方法init()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。Self代表了一件事情，那就是：类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是 self。

10.2 创建实例对象

实例化类其他编程语言中一般用关键字 new，但是在 Python中并没有这个关键字，类的实例化类似函数调用方式。

"创建 Employee类的第一个对象"
emp1 = Employee("Zara",2000)
"创建 Employee类的第二个对象"
emp2 = Employee("Manni",5000)

10.3 类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

在python中继承中的一些特点：

在继承中基类的构造（init()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

class Parent:
    # 定义父类
    parentAttr =100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print('调用父类方法')
    def setAttr(self,attr):
        Parent.parentAttr =attr
    def getAttr(self):
        print("父类属性 :",Parent.parentAttr)
 
class Child(Parent):
    # 定义子类
    def __init__(self):
        print("调用子类构造方法")  #无论子类还是父类，都要单独写一次_init_
    def childMethod(self):
        print('调用子类方法')
    def getAttr (self):
        print('重写父类方法，因为父类方法不能满足需求')
 
c = Child()  #实例化子类
c.childMethod()#调用子类的方法
c.parentMethod()#调用父类方法
c.setAttr(200)  #再次调用父类的方法 -设置属性值
c.getAttr()#再次调用父类的方法 -获取属性值

11 类的私有属性及方法

（1）类的私有属性

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

（2）类的私有方法

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

class JustCounter:
    __secretCount = 0
    # 私有变量
    publicCount = 0
    # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)  # 在内部使用私有化属性，不会产生错误
 
counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)
# 报错，实例不能访问私有变量