python基础入门2020-11-19

第一单元 python基本语法

教程内容来自路飞学城的免费文档,感谢前行者们的付出.

2020-11-18第三次编辑
2020-11-19第一次迁移到
2020-11-30修订

1.1 编程语言的分类

机器语言

优点是最底层，速度最快，缺点是最复杂，开发效率最低

汇编语言

优点是比较底层，速度最快，缺点是复杂，开发效率最低

高级语言

编译型语言执行速度快，不依赖语言环境运行，跨平台差

解释型跨平台好，一份代码，到处使用，缺点是执行速度慢，依赖解释器运行

1.2 Python介绍

Python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。

最新的TIOBE排行榜，Python赶超C++占据第3，与Java、C一起成为全球最流行的3大编程语言。

Python崇尚优美、清晰、简单，上手简单，非常适合做为第一门编程语言来学习。

Python可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。

python的优点

Python的定位是“优雅”、“明确”、“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序 .
开发效率非常高，Python有非常强大的第三方库
高级语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节
可移植性————由于它的开源本质，Python已经被移植在许多平台上
可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们
可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能

python的缺点

速度慢.对比编译型的c语言来说,是慢,但是对人来说是感觉不到的.
代码不能加密. 因为PYTHON是解释性语言，它的源码都是以名文形式存放的
线程不能利用多核.

1.3 python 语法

1.3.1 变量:

变量是保留在一段内存地址中的程序数据.变量是通过变量名来调用的.创建的变量名将指向内存中存储变量值的地址.当给一个变量名赋新值时,并不是将原有内存地址中的变量值更改,而是在内存中另外一个位置创建一个新值,变量名指向新的内存地址!

因此: 如果有变量a= 1,变量b=a,
则变量a的值是1,b的值是1
如果给变量a一个新值,a=2,则变量a的值是2,b的值仍然是1!
因为给变量a赋新值实际上在内存中一个新地址中创建的,然后变量a再指向这个新地址,但是变量b仍然指向原有内存地址中的数值,所以值仍为1.

变量命名规则:变量名只能是字母、数字或下划线的任意组合,第一个字符不能是数字,也不建议用""开头,因为""开头的名称在python中特殊含义.

变量名的书写:建议使用下划线体.也是python官方推荐如:

age_of_oldboy = 56

常量: python中没有常量,约定俗成的,使用全大写名称代表常量.

id()方法是查看变量内存地址的方法上例中

 >>>id (a) 
8791295723200 
>>>id (b) 
8791295723168

1.3.2 基本数据类型

1.3.2.1 数值型:

整型数 (int) 和浮点数 (float).python3中取消了整数的位宽,理论上整数可以取无限大.

>>> a = 2**22 
>>> a 
4194304 
>>> type(a)

1.3.2.2 字符串型:

在Python中,加了引号的字符都被认为是字符串！引号可以是单引号,也可以是双引号,甚至是三引号.三引号的作用就是可以进行换行,单引号或双引号定义字符时是不能换行的.

msg = "My name is Alex , I'm 22 years old!" 
msg = ''' 
            今天我想写首小诗， 
            歌颂我的同桌 
            你看他那乌黑的短发， 
            好像一只炸毛鸡。
      ''' 
print(msg)

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息

因此,字符串具有如下特点:

不可更改.对原字符串的修改,都实际上建立了一个新的数据
字符串是有序的列表,按从左到右的顺序,下标从0开始
可以进行切片操作

补充

字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r’l\thf’

字符串的常用操作

拼接,将字符串变量合并输出

例:

>>>name = "关羽"
>>>age = "32" 
>>>name +age 
'关羽32' 
>>>

字符串相乘:就是重复输出字符串

例:

>>>name*10
 '关羽关羽关羽关羽关羽关羽关羽关羽关羽关羽' 
>>>

字符串的拼接只能是字符串之间进行,字符串和其他的数据类型不能拼接
3 . 首字母大写.capitalize()

>>> s = 'maxiaoxue'
>>> s.capitalize()
'Maxiaoxue'

字符补完.cenetr(数,' 字符')

>>> s = 'maxiaoxue'
>>> s.center(15,'&')
'&&&maxiaoxue&&&'
>>>

统计指定范围内,指定字符的个数..count("字符",start,end)

>>> s
'maxiaoxue'
>>> s.count('a') 不指定范围就是全部
2
>>> s.count('a',3,8)  指定下标从3到8的范围.
1
>>>

6.判断是什么结尾 .endswith('字符'),可以获得文本结束的方式,控制程序选择.

>>> s
'maxiaoxue'
>>> s.endswith('ue') 判断是ue结尾的么?
True
>>> s.endswith('land')
False
>>>

从左到右找字符串中的某个值,如有返回第一个的下标 .find('字符',start,end)

>>> s
'maxiaoxue'
>>> s.find ('a')
1
>>> s.find('a',2,6)    # 可以指定查找的范围,这里找到的a的下标为4
4
>>> s.find ('c',2,6)  找不到就返回-1
-1
>>>

format 让字符串格式化输出
两种用法

用{}加数字的形式,变量替换{}内的内容.

 > s = "Welcome {0} to Apeland,you are No.{1} user."
 > s.format("Eva", 9999)
 'Welcome Eva to Apeland,you are No.9999 user.'

用{变量名}的形式,替换{}内的内容.更有灵活性

>>> s1 = "Welcome {name} to Apeland,you are No.{user_num} user."
>>> s1.format(name="Alex", user_num=999)
'Welcome Alex to Apeland,you are No.999 user.'

取得字符串中某个元素的下标 .index,用法同find
isdigit(self),判断是不是一个整数的字符串.返回的是布尔值

>>> '3'.isdigit()
True
>>>

islower(self): 判断字符串是不是都是小写字符

>>> 'A'.islower()
False
>>> 'abc'.islower()
True
>>> '32ab'.islower()
True
>>>

isspace(self): 判断字符是不是个空格
isupper():判断字符是不是全大写

>>> 'Acl'.isupper()
False
>>> 'ABC'.isupper()
True

join(self, iterable):方法用于将序列中的元素以指定的字符连接生成一个新的字符串.要联接的元素必须的字符串，否则会报错
str.join(sequence)

>>> n= ['maxiaoxue','girl','dear']
>>> '**'.join(n)
'maxiaoxue**girl**dear'
>>> 
>>> '=='.join(('l','o','v','e'))
'l==o==v==e'
>>>

1.3.2.3布尔型

布尔型只有两个值,一个是真(Ture),一个是假(False).计算机根据布尔值的结果,进行逻辑判断,从而决定程序的走向.

1.3.2.4列表(list)

就是其他语言中的数组,通过下标来标记一组信息的位置.使用时可以通过下标来方便的调用数据.

列表的特点:

1.可存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

3.可修改指定索引位置对应的值，可变

例:

>>>names = ['Alex', 'Jack', 'Rain', 'Rachel', 'Mack'] 
>>>names[2] #names [2] 指取出下标为2的数据 
>>>'Rain'

下标从0开始,每添加一个元素,下标就自动加1.从左向右顺序排列

image

列表中元素和下标的对应关系

列表中元素的添加删除修改和判断元素是否在列表中

列表元素的添加

插入元素: insert()

例:

>>>names
>>>['Alex', 'Jack', 'Rain', 'Rachel', 'Mack']
>>>names.insert(3,"小明")
# 3代表你想插入的位置,表示插入到下标为3的元素的前面 
# 插入不能插入到列表的尾部
>>>names
['Alex', 'Jack', 'Rain', '小明', 'Rachel', 'Mack']
>>>

在列表中追加元素:append()

追加是将元素加入到列表的尾部

例:

>>>names 
['Alex', 'Jack', 'Rain', '小明', 'Rachel', 'Mack'] 
>>>names.append("小强")
>>>names
['Alex', 'Jack', 'Rain', '小明', 'Rachel', 'Mack', '小强']

列表元素的修改

直接根据下标找到元素重新赋值即可

例:

>>>names[0] = "金角大王Alex" 
>>>names
['金角大王Alex', 'Jack', 'Rain', '小明', 'Rachel', 'Mack', '小强']

查操作:判断元素是否在列表中 in和取出元素下标

元素名 in 列表名,看返回的值是否为真.

>>>names 
['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强'] 
>>>"Mack" in names 
True

取出元素下标 index() 计算元素的个数count()

>>>names = ['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强']
>>>names.index("Mack") 
4  #如果有多个相同的元素,只返回从左到右匹配到的第一个元素的下标

计算列表中元素的个数

>>>names.append("金角大王Alex")
>>>names ['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛', '金角大王Alex']
>>>names.count("金角大王Alex") 
2
>>>

计算列表中一共有多少元素 len()方法

>>>len (names) 
7

删除元素 remove(),pop()和del方式

remove()方法

>>>names
['金角大王Alex', 'Jack', 'Rain', '小明', 'Rachel', 'Mack', '小强'] >>>names.remove("小明") 
>>>names 
['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强']

上面的命令会删除从左开始找到的第一个小明，如果有多个小明，则只删除找到的第一个。

del 删除

>>>del names[1] #删除下标为1的元素'jack' 
>>>names
['金角大王Alex', 'Rain', '小明', 'Rachel', 'Mack', '小强']

del是全局删除,可以删除变量.列表等所有数据

pop()删除, 默认删除最后一个元素并返回被删除的值 .加入下标可以删除指定的元素

>>>names 
['金角大王Alex', 'Jack', ['a', 'b'], 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛', '鸡头']
>>>names.pop() #留空的话,默认删除列表最后一个元素,并返回其值 '鸡头'  
>>>names.pop(2) #删除指定下标的元素,并返回其值 ['a', 'b'] 
>>>names
['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛'] 
>>>

6.列表的合并 extend ()方法

extend (要合并的列表名)将一个列表的值,追加到另一个列表的尾部.合并后的列表还是一个列表.

例:

>>>n1 = ["狗蛋","绿毛","鸡头"] 
>>>names.extend(n1) 
>>>names 
['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛', '鸡头'] 
>>>

列表的嵌套

列表的嵌套在是在一个列表中再包含另一个列表,这个嵌套进来的列表也是大列表中的一个元素.取值的方法和列表取值的方法一样,嵌入的方法也和列表插入的方法一样.

例:

>>>names
['金角大王Alex', 'Jack', 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛', '鸡头']
>>>names.insert(2,['a','b']) 
>>>names 
['金角大王Alex', 'Jack', ['a', 'b'], 'Rain', 'Rachel', 'Mack', '小强', '狗蛋', '绿毛', '鸡头'] 
>>>

嵌套取值: 取出上例中嵌套列表中的 'b'

例:

>>>names[2][1]
 'b' 
>>>

列表的清空clear()方法

例:

>>>n1 ['狗蛋', '绿毛', '鸡头'] 
>>>n1.clear() 
>>>n1 # 列表依然存在,但是其值被清空 
[]
>>>
>>>del n1 # 这将彻底清除n1列表变量 
>>>n1
Traceback (most recent call last):
 File "", line 1, in >>

列表的切片,反转,步长,循环和排序

列表的切片:

就是根据需要取出列表中的部分值.语法如下.

names[start:end]
列表变量名 [开始下标:结束下标]
列表的切片的地址定界下标,有顾头不顾尾的特点.取值时会取出开始下标的值但不会取出结尾下标的值.

例:下列列表[1:4],下标4的元素:狗蛋是不会显示.只显示1~3个下标的元素.

>>>names  
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']  
>>>names[1:4] #不包含下标4的元素  
['黑姑娘', 'rain', 'eva']

But,如果要取出最后一个元素怎么办呢? names[1:6]是不行的,因为列表切片是顾头不顾尾,最后一个下标仅能表示取值范围到此为止,只显示最后下标之前的内容.

这时,可以省略结束地址下标.就可以取到末尾. 
>>>names[3:] 
['eva', '狗蛋', '银角大王', 'eva'] 
同样的,省略开始下标,代表取出前面所有的元素 
>>>names[:3]
['金角大王', '黑姑娘', 'rain']
如果省略全部的地址下标就是取出所有元素 
>>>names[:] 
['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']
>>>

列表下标的排列从左到右依次是0,1,2,3----.从右到左顺序是-1,-2,-3,-4-----.

因此,要取出列表最未一位的元素可以写成

>>>names[-1] 
'eva'

思考:如果命令是names[-1:-5]会怎样?

结果是不会显示任何内容.只显示一个空列表.因为列表只能从左到右的依次显示.-1的右边是没有值的,因此显示为空.

列表的反转和步长

如果要实现-1,-2,-3顺序显示,实际上是将列表反转.要实现这个操作,要使用步长.

步长参数定义

names[start:end:step] step就是定义的步长默认是1

步长的应用:列表反转和跳跃取值

跳跃取值

>>>a = [1,2,3,4,5,6,7,8,9]
>>>a [::2] #步长设为2时的取值
[1, 3, 5, 7, 9] 
>>>a [::3] #步长设为3时的取值
[1, 4, 7] 
>>>

步长也可以设置成负值,设成-1,就实现了列表的反转输出.但列表中的元素排列实际没有变化,只不过是输出时是反转输出

>>>a 
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>a [::-1] 
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>

reverse()方法反转列表,列表中的元素排列也变化了,不是仅列表输出更改.

>>>a 
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>>a.reverse()
>>>a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

sort()方法对列表排序,像这种各种字符的混合,排序是依据ascII表的排列顺序来排序.

>>>names=['金角大王',  'rain',  '@',  '黑姑娘',  '狗蛋',  "4","#",'银角大王',  'eva']
>>>names.sort()
>>>names 
['#',  '4',  '@',  'eva',  'rain',  '狗蛋',  '金角大王',  '银角大王',  '黑姑娘']

ascII表

image

列表的循环: for 循环

设置临时变量i,用临时变量来循环列表.列表的每个元素顺序赋值给临时变量

>>>a 
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>for i in a: 
            print (i) 
1 
2 
3 
4 
5 
6 
7 
8 
9

思考:['金角大王', '黑姑娘', 'rain', 'eva', '狗蛋', '银角大王', 'eva']这个列表中,怎么取出第二个eva值的下标? (index()和for循环)

Python3列表中获取相同元素出现位置的下标

1.3.2.5 元组:tuple

元组又被称为只读列表，其元素不能修改。

定义：与列表类似，只不过［］改成（）

特性：
1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

创建:

ages =  (11,  22,  33,  44,  55) 
type (ages)

其他下标索引,查操作,切片,元组循环操作同列表操作.

元组中元素是不可变的,但是元组中插入的可变列表中的元素是可变的.

例:

>>> data 
(99,  88,  77,  ['Alex',  'Jack'],  33)
>>>data[3][0] =  '金角大王'   #修改元组中嵌套列表中的值
>>>data (99,  88,  77,  ['金角大王',  'Jack'],  33)

说明:元组中['Alex', 'Jack']这个元素的在内存中的地址是不可变的,但是alex和jack这两个值是存在另外的内存地址中的,这两个是可变的.就像杯子是不可变的,但是杯子中可以盛水,也可以盛酒一样.

1.3.2.6字典

列表可以遍历查询数据,但是如果这个列表中的数据很多,有许多重复的数据,列表的查询是非常麻烦的,也非常耗费资源.

接下来的字典可以实现查询数据又快、操作又方便，是日后开发中必备神器。

字典是Python语言中唯一的映射类型。

字典的定义

｛key1:value1,key2:value2｝

要用{}括起来
关键字key和值用冒号分开,冒号前面的是关键字key,后面的是值
key是唯一的,不可变数据类型,不可重复的
值可以有多个,并用","分开,可修改,可重复
字典无序
查询速度快,不受字典文件大小影响.

字典的创建

1. 
>>>person =  {"name":  "alex",  'age':  20} 
2. 
>>>person = dict(name='seven', age=20) 
或者 
>>>person = dict({"name":  "egon",  'age':  20}) 
3. 
>>>{}.fromkeys([1,2,3,4,5,6,7,8],100) 
{1:  100,  2:  100,  3:  100,  4:  100,  5:  100,  6:  100,  7:  100,  8:  100}

字典数据的追加

names =  { "alex":  [23,  "CEO",  66000], "黑姑娘":  [24,  "行政",  4000], } 
# 新增k 
names["佩奇"]  =  [26,  "讲师",  40000]

字典数据的删除要注意不同的方法所用括号的区别.

1.
names.pop("alex") # 删除指定key 
2.
names.popitem() # 随便删除1个key 
3.
del names["oldboy"] # 删除指定key,同pop方法 
4.
names.clear() # 清空dict

小练习传送门

删除操作

1.names.pop("alex") # 删除指定key
2.names.popitem()   # 随便删除1个key
3.del names["oldboy"] # 删除指定key,同pop方法
4.names.clear()     # 清空dict

修改操作
修改操作,同新增的方法.当新增的key存在时,其对应的内容会被新增的内容替换.若没有,就是新增一个数值.

dic['key'] = 'new_value' #如果key在字典中存在，'new_value'将会替代原来的value值；
dic.update(dic2) # 将字典dic2的键值对添加到字典dic中

查操作
只针对key有查询,不能查对应的值.因为值有多个且可重复

dic['key'] #返回字典中key对应的值，若key不存在字典中，则报错；
>>>dict_list = {}.fromkeys(["a","b","c","d","e","f"],100)
>>>dict_list
{'a': 100, 'b': 100, 'c': 100, 'd': 100, 'e': 100, 'f': 100}
>>>dict_list['b']
100
>>>dict_list['j']
Traceback (most recent call last):
  File "", line 1, in 
    dict_list['j']
KeyError: 'j'
'''为了避免在程序运行中出现上面的情况,可以用下面的get()方法,当元素不在字典中时,默认返回空值'''
>>>dict_list.get("b")
100
>>>dict_list.get("j")
>>>
'''根据返回真,假的值判定"'
>>> "f" in dict_list
True
>>> "j" in dict_list
False
>>> '''返回字典所有key的列表'''
>>> dict_list.keys()
dict_keys(['a', 'b', 'c', 'd', 'e', 'f'])
>>> '''返回一个包含字典所有value的列表；'''
dict_list.values() 
dict_values([100, 100, 100, 100, 100, 100])
'''返回一个包含所有（键，值）元组的列表'''
dict_list.items()
dict_items([('a', 100), ('b', 100), ('c', 100), ('d', 100), ('e', 100), ('f', 100)])

字典的循环
for k in dic # 推荐用这种，效率速度最快

>>> for k in dict_list:
    print (k,dict_list[k])

    
a 100
b 100
c 100
d 100
e 100
f 100
>>>

求长度,也可以返回列表的长度(元素个数)
len(dic)

1.3.2.7 集合

里面的元素不可变，代表你不能存一个list、dict 在集合里，字符串、数字、元组等不可变类型可以存

集合的特点:

天生去重，在集合里没办法存重复的元素

无序，不像列表一样通过索引来标记在列表中的位置，元素是无序的，集合中的元素没有先后之分，如集合{3,4,5}和{3,5,4}算作同一个集合
基于上面的特性，我们可以用集合来干2件事，去重和关系运算

集合的创建和转换

1. 创建
>>> a = {1,2,3,4,2,'alex',3,'rain','alex'}
>>> a
{1, 2, 3, 4, 'alex', 'rain'}
可见,集合会自动将重复的值去除
2. 转换
>>> b
[1, 2, 3, 4, 2, 'alex', 3, 'rain', 'alex']
>>> set(b)
{1, 2, 3, 4, 'alex', 'rain'}
>>> b = list(set(b)) #一句代码搞定列表去重

集合的增删改查

1. 集合的新增.add方法
>>> a = {1,2,3,4,'alex','java'}
#新增
>>> a.add('girl')
>>> a
{1, 2, 3, 4, 'girl', 'alex', 'java'}
#可见新加的元素,是无序排入集合中的
2.1 删除.discard
>>> a.discard('java')
>>> a
{1, 2, 3, 4, 'girl', 'alex'}
>>> a.discard('java')
>>> 
注意:删除一个不存在的元素,也没有错误信息提示
2.2 随机删除.pop,会返回所删除的值
>>> a.pop()
1
>>> a
{2, 3, 4, 'girl', 'alex'}
>>> 
2.3 用remove删除指定的元素
>>> a.remove(4)
>>> a
{2, 3, 'girl', 'alex'}
>>> 
3. 集合查找 ,也是用in的判断方法
>>> a
{2, 3, '黑姑娘', 'alex', 'rain'}
>>> 'alex' in a
True

集合的关系运算
集合天生去重,所以可以将数据存入不同的集合,来实现对数据不同的筛选.对于两个集合s1和s2来说,可有的关系运算有:

交集'&' : s1 & s2 :只列出两个集合共有的元素

并集 '|' : s1 | s2 : 列出两个集合所有的元素

差集 ' - ' : s1 - s2, 只列出只存在于s1中的元素.共有的元素和只存在于s2的元素将被忽略. s1={1,2,5,8},s2= {1,2,6,8},s1 - s2的结果是5.可以理解成列出s1中不同于s2的元素.

对称差集 ' ^ ': s1 ^ s2,将同时存在于两个集合的元素摒弃. 相当于取交集的反结果.

两个集合之间一般有三种关系进行逻辑判断，相交、包含、不相交.返回Ture或False的值

.isdisjoint是否相交
.issubset 是子集么
.issuperset 是父集么
print(s1.isdisjoint(s2))     # 判断2个集合是不是不相交，返回True or False
print(s1.issubset(s2))       # 判断s1是不是s2的子集，返回True or False
print(s1.issuperset(s2))     # 判断s1是不是s2的父集，返回True or False