python

一、Python介绍

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

二、发展历程

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。
Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。
像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。
现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用。

三、Python的特点

易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
易于阅读：Python代码定义的更清晰。
易于维护：Python的成功在于它的源代码是相当容易维护的。
一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
数据库：Python提供所有主要的商业数据库的接口。
GUI编程：Python支持GUI可以创建和移植到许多系统调用。
可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"

四、第一个Python程序

1.创建python file
2.练习打印hello world

image.png

五、Python变量和数据类型

5.1. 变量的定义
在程序中，有时我们需要对2个数据进行求和，那么该怎样做呢？
大家类比一下现实生活中，比如去超市买东西，往往咱们需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可
如果在程序中，需要把2个数据，或者多个数据进行求和的话，那么就需要把这些数据先存储起来，然后把它们累加起来即可
在Python中，存储一个数据，需要一个叫做变量的东西，如下示例:

num1 = 100 #num1就是一个变量，就好一个小菜篮子
num2 = 87  #num2也是一个变量
result = num1 + num2 #把num1和num2这两个"菜篮子"中的数据进行累加，然后放到 result变量中

概念

整数
Python可以处理任意大小的整数，当然包括负整数，在Python程序中，整数的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。
布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。
布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为 True，and运算结果才是 True。A与B true true
or运算是或运算，只要其中有一个为 True，or 运算结果就是 True。
not运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

代码示例

a=1;
#浮点数
b=1.1;
#字符串
c="abc";
#boolean类型
d=True;
#空值
e=None;
print(a);print(b);print(c);print(d);print(e)
a=True and True   # ==> True
b=True and False   # ==> False
c=False and True   # ==> False
d=False and False   # ==> False
e=True or True   # ==> True
f=True or False   # ==> True
g=False or True   # ==> True
h=False or False   # ==> False
i=not True   # ==> False
j=not False   # ==> True
print(a,b,c,d,e,f,g,h,i,j)

标识符

1、什么是标识符？
开发人员在程序中自定义的一些符号和名称
标识符是自己定义的,如变量名 、函数名等
2、标识符的命名规则
. 标识符只能由字母、下划线“_”、数字组成。
. 标识符不能以数字开头。
. 标识符不能使用关键字
. 标识符对大小写敏感。
（建议:标识符命名应“见名知意”）
3、python中的关键字
'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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'

Python中print语句

print() 方法用于打印输出，最常见的一个函数。
语法:
print(*objects, sep=' ', end='\n', file=sys.stdout)
参数:
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
格式化输出

方式一:使用百分号（%）字符串格式化

print("my name is %s, and my age is %d" %(name,age))
方式二：使用format字符串格式化

位置参数

print("my name is {}, and my age is {}".format(age,name))
关键字参数

print("my name is {name}, and my age is {age}".format(age=18,name="jack"))

注释:位置参数("{0}".format())，关键字参数("{关键字}".format())

设置换行符号

input() 用来获取控制台的输入。
语法：
input([prompt])

image.png

六Python条件循环和判断

If语句

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

其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，具体

#####If else 语句
age = 12
if age>18:
    print("年龄大于18")
else:
    print("年龄小于等于18")

age=20;
if age>18:
    print("年龄大于18")
if not age <=18:
    print("年龄大于18")
注意：Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的 print 语句就构成一个代码块。如果 if 语句判断为 True，就会执行这个代码块。

If else else 多层嵌套方式

age=10;
if age >= 18:
    print ('adult')
else:
    if age >= 6:
        print ('teenager')
    else:
        if age >= 3:
            print ('kid')
        else:
            print ('baby')

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
For循环：重复执行语句

for n in range(1, 20):
    print(n)

arr = [100, 90, 86, 80, 77]
for index in arr:
    print(index)

注意: b这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体

While 循环

Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。

while 判断条件：
    执行语句……

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束,while 循环不会迭代 list 或 tuple 的元素

元组

元组的格式

变量名=(,,,,)

访问元组

通过索引取数据

aTuple=(23,35,56,34,11,21)
print(aTuple[2])
#56

查询个数

count查询出现的个数

查询索引

index：查询元素的索引，有对应的元素返回对应的索引，否则报错

修改数据(不能修改)

aTuple=('b','c','d','e','f','g')
aTuple[1]=23
#TypeError: 'tuple' object does not support item assignment

类型转换

aa = [23,34,45,56,67]
tuple(aa)
print(aa)
#[23, 34, 45, 56, 67]

列表转换元组

aTuple=('b','c','d','e','f','g')
a = list(aTuple)
print(a)
#['b', 'c', 'd', 'e', 'f', 'g']

元组转换列表

aa = [23,34,45,56,67]
tuple(aa)
print(aa)
#[23, 34, 45, 56, 67]

元组的循环取值

方式一：for

aTuple=('b','c','d','e','f','g')
for i in aTuple:
    print(i)

方式二：while

aTuple=('b','c','d','e','f','g')
i=0
while i < len(aTuple):
    print(aTuple[i])
    i=i+1

字典

字典的格式

变量名={key1:value,key2:value,,,}

字典的每个元素由2部分组成，键（key）:值（value）

根据键访问值

有对应key的

info = {"name":"wjh","age":18,"sex":"男"}
print(info["name"])

无对应key的

info = {"name":"wjh","age":12,"sex":"男"}
print(info["name12"])

修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改,否则是新增

info = {"name":"wjh","age":12,"sex":"男"}
info["age"] =14
print(info)
#{'name': 'wjh', 'age': 14, 'sex': '男'}

有对应的key则是修改数据，没有对应的key是新增数据

添加元素

info = {"name":"anfly","age":12,"sex":"男"}
info["gender"] ="属鸡"
print(info)
#{'name': 'anfly', 'age': 12, 'sex': '男', 'gender': '属鸡'}

删除元素

del,clear() ---- 清空

del (删除指定的元素)

删除整个字典

info = {"name":"anfly","age":12,"sex":"男"}
del info
print(info)
#NameError: name 'info' is not defined

删除某个元素

info = {"name":"anfly","age":12,"sex":"男"}
del info["name"]
print(info)
#{'age': 12, 'sex': '男'}

clear清空

info = {"name":"anfly","age":12,"sex":"男"}
info.clear()
print(info)
#{}

查询长度

len():查询键值对的个数

info = {"name":"anfly","age":12,"sex":"男"}
print(len(info))
#3

字典中循环

取出字典中的key

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.keys():
    print(i)

取出字典中的value

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.values():
    print(i)

取出字典中的key和value

方式一：

info = {"name":"anfly","age":12,"sex":"男"}
for i in info.keys():
    print(i,info[i])

方式二：

info = {"name":"anfly","age":12,"sex":"男"}
for k,v in info.items():
    print(k,v)

集合和函数

集合

集合的特征

集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重

集合的格式

变量名=set()
变量名.add(元素)
# 必须不能初始化值

添加元素

add

nums = {11,24,45,96,28}
nums.add(42)
print(nums)
#{96, 42, 11, 45, 24, 28}

update

nums = {11,24,45,96,28}
nums2=["anfly","tom"]
nums.update(nums2)
print(nums)
#{96, 'anfly', 11, 45, 24, 28, 'tom'}

删除元素

remove，pop，discard

remove

使用remove删除集合中的元素 如果有直接删除 如果没有程序报错
该元素存在

nums = {11,24,45,96,28}
nums.remove(24)
print(nums)
#{96, 11, 45, 28}

该元素不存在

nums = {11,24,45,96,28}
nums.remove(245)
print(nums)
#KeyError: 245

pop

使用pop删除是随机删除集合中的元素 如果集合没有元素程序报错
有元素

nums = {11,24,45,96,28}
nums.pop()
print(nums)
#{11, 45, 24, 28}

无元素

nums = {}
nums.pop()
print(nums)
#TypeError: pop expected at least 1 arguments, got 0

discard

使用discard删除 如果元素存在直接删除 如果元素不存在不做任何操作
该元素存在

nums = {11,24,45,96,28}
nums.discard(24)
print(nums)
#{96, 11, 45, 28}

该元素不存在

nums = {11,24,45,96,28}
nums.discard(242)
print(nums)
#{96, 11, 45, 24, 28}

集合的交集和并集

交集

使用&连接多个集合,得到相同的元素
存在相同元素

set1 = {"anfly","tom","haha"}
set2 = {"anfly","susala"}
set3= set1 & set2

print(set3)
存在相同元素

set1 = {"anfly","tom","haha"}
set2 = {"anfly2","susala"}
set3= set1 & set2
print(set3)

并集

使用|连接多个集合,得到全部集合中全部的元素

公共方法

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 | set2
print(new_set)
#{1, 2, 3, 4, 5, 6}

运算符

image

函数

什么是函数

在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数

函数定义和调用

def 函数名():
    执行语句
函数名()    #调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用
每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
当然了如果函数中执行到了return也会结束函数

位置参数

def 函数名(参数1,参数2):
    代码块
函数名(值1,值2)

关键字参数

def 函数名(参数1,参数2):
    代码块
函数名(参数1=值1,参数2=值2)

缺省参数

在形参中默认有值的参数，称之为缺省参数

def printinfo(name,age=20):
    print("name:",name)
    print("age:",age)
printinfo(name="anfly")
#name: anfly
#age: 20

调用函数时，缺省参数的值如果没有传入，则取默认值（形式参数），如果传入，则取实际参数
缺省参数一定要位于位置参数的最后面

不定长参数

有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。

def printinfo(*args,**kwargs):
    print("args:",args)
    print("kwargs:",kwargs)
printinfo(参数)

注意：加了星号（）的变量args会存放所有未命名的变量参数，args为元组
而加*的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典

参数位置顺序

def fun(位置参数,*args,缺省参数,**kwargs):
    代码块
fun(参数值)

注意:•如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 args的后面， 但如果有kwargs的话，*kwargs必须是最后的

函数返回值

def sum():
    代码块
    return 值
sum()

多个return

  def create_nums(num):
      print("---1---")
      if num == 100:
          print("---2---")
          return num+1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
          print("return执行之后不会继续执行")
  print(“1231223")
      else:
          print("---3---")
          return num+2
      print("---4---")
  result1 = create_nums(100)
  print(result1)  # 打印101
  result2 = create_nums(200)
  print(result2)  # 打印202

注意:一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

返回多个数据

    shang = a//b    #取模
    yushu = a%b    #取余
    return shang, yushu  #默认是元组
result = divid(5, 2)
print(result)
# 输出(2, 1)

总结:return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据

函数类型

无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

def printMenu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

无参数，有返回值的函数

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

def getTemperature():
    # 这里是获取温度的一些处理过程
    # 为了简单起见，先模拟返回一个数据
    return 24

有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

有参数，有返回值的函数

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

# 计算1~num的累积和（案例需实际演示）
def calculateNum(num):
    result = 0
    i = 1
    while i<=num:
        result = result + i
        i+=1
    return result

函数的嵌套

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

def testb():
    print("testb start")
    print("testb testb  执行")
    print("testb end")
def testa():
    print("testa start")
    testb()
    print("testa end")

注意：如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置

匿名函数

lambda函数也叫匿名函数，即函数没有具体的名称

g = lambda x :x+1
print(g(1))

def g(x):
    return x + 1
print(g(1))

注意:lambda函数可以赋值给变量，默认是返回的，所以不用再加return关键字

变量

局部变量

定义
局部变量，就是在函数内部定义的变量
局部变量，就是在函数内部定义的变量
约束
其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的

def test1():
    a = 120
    print("我是局部变量a:",a)
    a = 240
    print("修改之后的局部变量a:",a)
def test2():
    a =360
    print("我是test02函数中的局部变量a",a)
test1()
test2()

注意:局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

全局变量

定义
在函数外边定义的变量叫做全局变量
约束
全局变量能够在所有的函数中进行访问

a = 100
def test1():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据
def test2():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据
# 调用函数
test1()
test2()

全局变量和局部变量名字相同

a = 100  #全局变量
def test1():
    a= 300
    print("修改后的a:",a)
def test2():
    print(a)
# 调用函数
test1()
test2()

注意:函数中的变量修改不会导致全局变量改变

全局变量的修改

global的使用

a = 100  #全局变量
def test1():
    global a   #将a变成全局变量
    a= 300
    print("修改后的a",a)
def test2():
    print(a)
# 调用函数
test1()
test2()

注意:在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据 也理解为对全局变量进行修改，而不是定义局部变量