Python基础01

时间 2019-11-16

标签 python 基础栏目 Python 繁體版

原文原文链接

　　记得2015年刚上大学的时候，选的所有是计算机专业，因为高考考得很差，考了一个普通二本院校，学得是计算机相关专业（网络工程-物联网方向）。现今即将大学毕业，大学期间，计算机的基础知识都在校园里面学过。第一门编程语言学的是C语言，即将去双非学校去读研究生，考得是学硕--计算机应用技术。我的对于大数据，人工智能，机器学习等方面比较感兴趣，因此准备先进行Python的学习，找视频学习一个全栈知识，知道学习周期很长，为了之后的更好的服务于研究的方向，本身会加油努力。java

　　时间过得很快，人生可能也是如此。python

　　不将就，成为更好的本身，为社会多作点本身力所能及的事，也为本身的追求。人活着，老是要有点气节的，没有灵魂地活着，和尸体有何区别！git

　　感谢帮助个人亲人，朋友等，正是因为大家在个人身边，我才会有一往无前的信心！web

　　谢谢！面试

写在前面：编程

　　所用的开发环境：api

　　编程工具使用的是：Pycharm，具体的安装，上网找一下，就会有相关的介绍，基本上就是“下一步”就能够了，在这里就不介绍了。数组

　　在文本编辑方面，我以为Notepad++是分好用，推荐使用。网络

主要知识点：app

Python的基础知识：

1、Python的介绍

一、python的诞生

　　崇尚优美、清晰、简单

　　2019年5月TIOBE编程语言排行榜单排行：

　　Python的主要应用领域：

　　云计算：
       WEB开发：
       科学运算、人工智能
       系统运维
       金融
       图形GUI

　　Python2.X与Python3.X的宏观区别：

　　　　python2源码不标准、混乱、重复代码太多

　　　　python3统一标准，去除重复代码。

　　Python发展史：

　　　　在宏观上Python2.X与Python3.X的区别：

　　　　　　Python2.X源码不标准、混乱、重复代码多。

　　　　　　Python3.X统一标准、去除重复代码。

　　　　　　　　　　2.7版本支持到2020年以后2版本就不会再进行更新

　　　　　　python 2.4版本————web框架Django诞生

　　　　　　python 3.0版本————2008年10月3

二、python是什么编程语言

　　编译型：一次性将全部程序编译成二进制文件

　　　　缺点：出现bug从新再编译，开发效率低，不能跨平台；

　　　　优势：运行速度快。

　　解释型：程序执行，一行一行解释

　　　　缺点：运行速度慢；

　　　　优势：开发效率高，能够平台。

　　python是一种解释型的强类型定义语言

三、python的优缺点

　　Python优势：

　　　　优雅、明确、简单

　　　　开发效率高：直接调用第三方库

　　　　高级语言

　　　　可移植性

　　　　可扩展性

　　　　可嵌入式：能够把Python嵌入C等语言中

　　Python的缺点：

　　　　运行速度慢（相比于编译型）

　　　　总体代码不能加密

　　　　线程不能利用多CPU

四、python的种类

    CPython：在C语言中能够写python，而后CPython将Python转换成C的字节码，再转换为0101。
   IPython
   JYPython：java平台下的Python
   PYPY：将Python解释型语言，一次性所有编译成字节码（解释型），速度很快；等等

2、python的环境

　　Python环境的安装教程，网上都有不少，这里就不详细描述。

　　使用的编辑器是集成开发环境，Pycharm

3、Python基础初识

一、运行第一个Python代码

　　按住win+R，而后输入“cmd”回车

　　Python+空格+文件路径

　Python2默认编码方式是ASCII码，不支持中文。Python3默认编码方式是UTF-8，支持中文；

　　　　解决方法：在代码最前面加上

# -*- encoding:utf-8 -*-

注解：在cmd命令行默认的编码是gbk,因此不会报错，可是会出现乱码

执行下面代码，会得出相应的Python优秀代码书写的指导原则。

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
译文：

　　优美胜于丑陋
　　显式胜于隐式。
　　简单胜于复杂。
　　复杂胜于难懂。
　　扁平胜于嵌套。
　　稀疏胜于紧密。
　　尽管实用性会战胜纯粹性，特例也不能凌驾于规则之上。
　　不要忽略任何错误，除非你确认要这么作。
　　面对不明确的定义，拒绝猜想的诱惑。
　　找到一种最好惟一的一种方法去解决问题。
　　虽然一开始这种方法并非显而易见，由于你不是Python之父。
　　作好过不作，但没有思考的作还不如不作。
　　若是实现很难说明，那它是个坏想法。
　　若是实现容易解释，那它有多是个好想法。
　　命名空间是个绝妙的想法，请多加利用。

二、变量

　　变量：就是将一些预算的中间结果存储下来，以便后续的代码使用。

　　变量命名规则：

　　　　一、必须由字母、数字、下划线任意组合，且不能以数字开头；

　　　　二、不能使用Python的关键字；

　　　　　　全部关键字：[and、elif、import、return、

　　　　　　　　　　　　as、else、in、try、assert、except、is、

　　　　　　　　　　　　while、break、finally、lambda、with、

　　　　　　　　　　　　class、for、not、yield、continue、from、

　　　　　　　　　　　　 or、def、global、pass、del、if、raise]

　　　　三、变量要具有实际的意思，经常使用驼峰体或者下划线分割（推荐）。

　　　　四、不能是中文，中文不会报错。

　　说明：

　　　　记住Python是解释型语言（赋值先算等号右边的）；

三、常量

　　常量：一直不变的量。（Python中没有常量这个概念）

　　约定俗成搞一个常量，常量所有用大写表示。

四、注释

   方便本身，方便他人理解代码
   单行注释：#
   多行注释：'''被注释内容''' 或者是   """被注释内容"""

五、用户交互

　　样例：

name = input('请输入你的名字：')
age = input('请输入你的年龄：')
print(name, age,type(age))
print('个人名字是'+name,'个人年龄'+age+'岁')

　　　一、等待输入；
　　　　二、将你输入的内容赋值给了前面的变量；
　　　　三、input出来的数据类型所有是str。

六、基础数据类型

　　数字：int 12,3

　　　　判断数据类型： type()
数字转化成字符串str(int)
用int(str)进行字符串转化的时候，字符串必须所有是数字组成的

print(100,type(100))
print('1000',type('1000'))

　　　　取值范围:32位机。范围为-2^31-2**31-1
          64位机。范围为-2^63-2**63-1
          Python中没有long的概念
　　　　能够进行：+ - * /
          % 取余
          **幂运算

　　字符串：str
　　　　Python中凡是用引号（单双无所谓）引发来的都是字符串
   在字符串中有单引号的时候要注意包含关系。
   操做方法：
   　　　　字符串相加用 ‘+’ 能够无缝拼接
   　　　　字符串能够与数字相乘：str*int （重复多遍）
   　　　　三个引号引发来，（涉及到换行必须用三个引号）若是赋值给变量，就是一个大的字符串　　　　

msg = '''
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
'''
print(msg)

结果：打印出msg里面的那首诗。

　　布尔值：
　　　　只有两种状态True和False；

　　　　在判断的时候运用。

Python控制流

　　在Python中有三种控制流语句-- if、for和while。

七、if--条件判断

　　if 条件：
　　　　if-块

　　elif（可选）：

　　　　elif-块

　　else（可选）：

　　　　else-块

　　说明：经过缩进来展示结果块，来进行格式控制
第一种：

if 5 > 4:
    print(6666)
    print(77777)

结果：6666 77777
第二种：

if 4 > 3:
    print('我请你喝酒')
else:
    print('喝什么酒')

结果：我请你喝酒
多选：

num = input('请输入您猜的数字：')
if num == '1':
    print('一块儿抽烟')
elif num == '2':
    print('一块儿喝酒')
elif num == '3':
    print('新开了一家，走看看')
else:
    print('你猜错了...')

多个条件只走一个

num = int(input('请输入您猜的数字：'))

if num == 1:
    print('一块儿抽烟')
elif num == 2:
    print('一块儿喝酒')
elif num == 3:
    print('新开了一家，走看看')
else:
    print('你猜错了...')

if嵌套：

name = input('请输入名字：')
age = input('请输入年龄：')
if name == '小二':
    if age == '18':
        print(666)
    else:
        print(3333)
else:
    print('错了....')

备注：不像C/C++,在Python中没有switch语句，可是可使用if来进行实现

八、while--循环

当while后面的条件是真时，while中的循环体就会开始执行。

while True:
    print('咱们不同')
    print('在人间')
    print('痒')
print('2222')

结果：一直进行循环，能够执行，不会报错

#利用while循环实现从1到99的打印：

count = 1
flag = True
 
while flag:
    print(count)
    count = count + 1
    if count > 100:
        flag = False

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

#用while循环实现从1加到100

sum = 0
count = 1

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

固定搭配 while...else...

count = 0
while count <= 5:
    count += 1
    if count == 3:
     # 1   break
        pass
else:
    print("循环正常执行完啦")
print("-----out of while loop-----")

九、for--循环

for in是另一个循环语句，它通常用在一序列对象的迭代上，即逐一使用序列中的每一个项目。（序列会在后面的博客中介绍）

for i in range(1, 5):
    print(i)
else:
    print('The for loop is over')

这里使用了内建函数range生成了一个序列，else部分是可选的，输出结果：

1
2
3
4
The for loop is over

备注：Python中的for循环，相对于C/C++来讲，确实简单，不易出错。

s = 'sdvvebr'
for i in s:     #s能够是字符串，列表，元组，字典
    print(i)

十、break语句

无论while后面的判断条件是真仍是假，只要运行到break语句就会终止该循环，多层循环嵌套，终止本层循环。

print('1111')
while True:
    print('2222')
    print('3333')
    break
    print('4444')
print('abcde')

运行结果：

1111
2222
3333
abcde

注解：参照结果，会发现，'4444' 没有被打印出来，由于break语句终止了while循环。

#从1打印到100

count = 1
while True:
    print(count)
    count = count + 1
    if count > 100:break

十一、continue语句

continue语句被用来告诉Python跳过当前循环的剩余语句，而后继续进行下一轮循环。在while循环和for循环中均适用（结束本次循环，执行下一次循环）。

count = 0
while count <= 100:
    count +=1
    if count > 5 and count < 95:
        continue
    print("loop",count)    
print("------out of while loop-------")

运行结果：loop 1 ~ loop 100,最终打印 ------out of while loop-------

#使用continue语句打印1-20

print(111)
count = 1

while count <= 20:
    print (count)
    count = count + 1
    continue

注解：若是上面的代码第6句和第7句进行了互换，就会出现一直打印1，不停歇。

十二、格式化输出

Python中的格式化输出就 % 和 format

（1）%占位符（s表示字符串，d表示数字，%%只是单纯的显示百分号）

例如：

#% s d
name = input('请输入姓名:')
age = input('请输入年龄:')
height = input('请输入身高:')
msg = "我叫%s，今年%s，身高%s" %(name,age,height)
print(msg)

注解：若是输出的msg中有相关的须要用%来表示的要用两个%（其中第一个%转义）

样例一

name = input("请输入姓名：")
age = int(input("请输入年龄："))
height = input("请输入身高：")
msg = '''
========= info of %s =========
name:%s
age:%d
height:%s
============= end =============
''' %(name, name, age,height)
print(msg)

（2）format的三种样式

s = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('张三',36,'girl','喋血弑神')
print(s)
name = input("请输入名字：")
s2 = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format(name,36,'girl')
print(s2)
name = input("请输入名字：")
s3 = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(name=name,age=36,hobby='girl')
print(s3)

1三、编码

不管是电脑的传输还有储存，都是0101001
   ASCII码
       最开始设计7位，为了之后的发展预留了1位，第一位是0
       8bit = 1Byte
       1024Byte = 1KB
       1024KB = 1MB
       1024MB = 1GB
       1024GB = 1TB
    因为中文九万多字，不可以知足国际的众多语言的使用。
       美国为了解决这个问题，提出了万国码（Unicode）
   最开始：
       1个字节能够表示全部的英文和特殊字符
       2个字节，16位，65535，中文不够。
           Unicode一个中文用4个字节表示。
    Unicode太浪费空间-》升级utf-8，一个中文用3个字节表示
       Python2默认使用ASCII码，因此打印中文会报错；
   gbk，国内使用，中国人本身建立的，只包含中文，一个中文用2个字节表示

1四、运算符

运算符分为三种：算数运算符，比较运算符，逻辑运算符

（1）算数运算符

　　+-*/ %（取余） //（整除）

（2）比较运算符

　　> < >= <= ==（比较相等）！=（不等于）

（3）逻辑运算符

　　and or not（与，或，非）
　　优先级：

　　　　两边不等式：

　　　　　　　　() > not > and > or,同级自左向右

　　　　两边数字：　　　　

　　　　　　　　X or Y ,X 为True，则返回X

　　　　　　　　X and Y ,X 为True，则返回Y(and和or相反)

　　　　数字转换成布尔值：

　　　　　　　　非零的转换成布尔值是True，零转换成布尔值是False

　　　　布尔值转换成数字：

　　　　　　　　True转换成数字是1，False转换成数字是0

1五、数据类型

（1）int：相似于1，2，3这样的，主要用于计算

主要的方法：

　　bit_length():将int类型的数据转换成二进制的最少位数

i = 7
print(i.bit_length())

结果：3，数字7转化为二进制是111，最少的二进制位数是3

（2）bool：True和False，主要用于判断真假

（3）str：用引号引发来的都是字符串，主要是储存少许数据，进行操做。

　　第一部分：str的索引和切片

　　　　　　str的索引第一位是从0开始的；

s = 'ABCDEFghijkl'
s1 = s[0]
print(s1)           #结果：A
s2 = s[2] 
print(s2)           #结果：C

　　　　　　str的切片，原来的字符串不变，顾头不顾尾

s = 'ABCDEFghijkl'
s3 = s[0:4]
print(s3)    #结果：ABCD
s4 = s[-1]   #取最后一位，倒着数，从-1开始
print(s4)    #结果：l
s5 = s[-2]   #取最后一位
print(s5)    #结果：k
s6 = s[:]
s7 = s[0:]
print(s6,s7)   #结果：均全取
s9 = s[0:0]
print(s9)      #结果：空

　　　　　　切片，跳着取,加一个步长。默认是1。格式：s[首:尾:步长]，倒着取,就是负的，顾头不顾尾

s = 'ABCDEFghijkl'
s10 = s[0:5:2]
print(s10)  #结果：ACE
s11 = s[3::-1] 
print(s11)  #结果：DCBA

　　第二部分：str的经常使用操做方法（产生新的字符串，不影响原来的字符串）

　　　　　　①capitalize()：只是首字母大写

s = 'ABCDEFghijkl'
s1 = s.capitalize()
print(s1)            #结果：Abcdefghijkl

　　　　　　②upper()：字符串所有大写

s = 'ABCDEFghijkl'
s2 = s.upper()
print(s2)            #结果：ABCDEFGHIJKL

　　　　　　③lower()；字符串所有变小写

s = 'ABCDEFghijkl'
s3 = s.lower()
print(s3)            #结果：abcdefghijkl

　　　　　　④swapcase()：大小写翻转（大写变小写，小写变大写）

s = 'ABCDEFghijkl'
s3 = s.swapcase()
print(s3)            #结果：abcdefGHIJKL

　　　　　　⑤title()：每一个隔开的单词首字母大写(除了英文字母以外的全部都是特殊字符)

s = 'ABCDEF ghijkl'
s4 = s.title()
print(s4)             #结果：Abcdef Ghijkl

　　　　　　⑥center()：设定总宽度居中，默认空格填充，能够作设置字符填充

s = 'ABCDEFghijkl'   
s5 = s.center(20,'#')
print(s5)            #结果：####ABCDEFghijkl####

　　　　　　⑦expandtabs()：总共八个字符，不足8位补空格

s = 'ABCDEF\tghijkl'
s6 = s.expandtabs()
print(s6)              #结果：ABCDEF  ghijkl
s = 'AB\tghijkl'
s6 = s.expandtabs()
print(s6)              #结果：AB      ghijkl

　　　　　　⑧replace()：替换

s = 'fegegwfegqhhii'
s11 = s.replace('e','王',1)  #默认所有替换，加数字表示替换多少处
print(s11)                   #结果：f王g王gwfegqhhii

　　　　　　⑨is系列

name = 'zhangsan123'
print(name.isalnum())     #结果：True，字符串由字母和数字组成
print(name.isalpha())     #结果：False，字符串只由字母组成
print(name.isdigit())     #结果：False，字符串只由数字组成

公共方法：

①len()：查看长度

s1 = 'nihao你好'
num = len(s1)
print(num)     #结果：7

②startwith()：判断字符以什么为开头

s = 'ABCDEFghijkl'
s7 = s.startswith('AB')
if s7:
    pass
elif s.startswith('bl'):
    pass
print(s7)                  #结果：True
s71 = s.startswith('e',2,5)# 从2到5是否以e为开头
print(s71)                 #结果：False

③endwith()：判断字符以什么为结尾，方法和startwith()类似

④find()：返回位置索引,返回数字

#若是是总体返回第一个字符的索引，找不到返回-1
s = 'ABCDEFghijkl'
s8 = s.find('gh')
print(s8,type(s8))     #结果：6 <class 'int'>
s8 = s.find('CD')
print(s8,type(s8))     #结果：2 <class 'int'>

⑤index()：经过元素找索引，找不到报错

s = 'ABCDEFghijkl'
s8 = s.find('A')
print(s8,type(s8))      #结果：0 <class 'int'>
s81 = s.index('Z')      #结果：报错

⑥strip(), rstrip(), lstrip()：默认删除先后空格，中间有空格不行

s = 'ABCDEF ghijkl'
s9 = s.strip()
print(s9)
username = input('请输入姓名：').strip()
if username == '张三':  #可能随手加空格
    print('恭喜发财！！！')
s = '#李 四$'
s91 = s.strip(' $#')  #只要出现的最小的单个元素就删
print(s91)

⑦count()：计数，没有为0

s = 'AAAABCDEFghijkl'
s10 = s.count('A')
print(s10)               #结果：4

⑧split()：数据类型的转换 str----》list，遇到分隔符一分为二

s = ':ABC:def:GHI'
l = s.split(':')
print(l)#结果：['', 'ABC', 'def', 'GHI']

int，bool，str之间的转换：

int ----> str，  没有条件，直接用str(int)方法转换；

int ----> bool， 只要是零就是False，非零为True；

str ----> int， str只能是数字；

str -----> bool， 空字符串就是False，只要有数据就是True，哪怕是有一个空格都是True；

bool -----> int， True转换成数字就是1，False转换成数字就是0（ps:True 的效率比写1效率低，例如：while 1：（由于要转换成机器码））。

（4）list：[1,2,3,'名字'，[1,2,3]，主要用于存储大量的数据

（5）元组：（1,2,3，'姓名'），只能读，可以存储大量的数据

（6）字典：{'name'：'姓名'，‘age’：18}，主要存储大量的关系型数据

（7）集合：{1,2,3,'abcd'}

1六、列表

列表是由一系列按照特定顺序排列的元素，能够在列表中加入任何东西，其中的元素之间没有任何关系。

因为列表中包含多个元素，因此通常给列表制定一个表示复数的名称。

访问列表中的元素（列表中元素的下标是从0开始的）

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
l1 = names[0]
print(l1)    #结果：tom
l2 = names[1]
print(l2)    #结果：[1, 2, 3]
l3 = names[0:3]    #取前面3个
print(l3)    #结果：['tom', [1, 2, 3], 'Andy']

增（3种）

append()：原列表进行增长

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.append('日天')
names.append(1)
print(names)　　#结果：['tom', [1, 2, 3], 'Andy', 'egon', '杰伦', 'sandy', '日天', 1]

insert()：插入

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.insert(5,'春哥')
print(names)　　#结果：['tom', [1, 2, 3], 'Andy', 'egon', '杰伦', '春哥', 'sandy']

extend()：分解成元素，添加元素

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.extend('二哥')
#names.extend(123) # int 是一个总体，不能迭代
names.extend([1,2,3])
print(names)　　　　#结果：['tom', [1, 2, 3], 'Andy', 'egon', '杰伦', 'sandy', '二', '哥', 1, 2, 3]

删（4种）

pop()：按索引去删除，返回值是要删除的元素

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.pop(0)
print(names)　　#结果：[[1, 2, 3], 'Andy', 'egon', '杰伦', 'sandy']
names.pop()     # 默认删除的是最后一个元素
print(names)　　#结果：[[1, 2, 3], 'Andy', 'egon', '杰伦']

remove()：按元素去删除，没有返回值

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.remove('egon')
print(names)　　#结果：['tom', [1, 2, 3], 'Andy', '杰伦', 'sandy']

clear()：清空列表

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names.clear()
print(names)　　#结果：[]

del：删除列表，而且能够切片去删

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
del names
print(names)   # 会报错，由于已经没有了names列表

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
del names[2:5]
print(names)　　#结果：['tom', [1, 2, 3], 'sandy']

改（2种）

找到对应的索引直接赋值就行

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names[0] = '张三'
names[2] = [4, 5, 6]
print(names)　　#结果：['张三', [1, 2, 3], [4, 5, 6], 'egon', '杰伦', 'sandy']

切片修改，按照迭代去赋值，拆分填多少无所谓

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
names[0:2] = '李四'
print(names)　　#结果：['李', '四', 'Andy', 'egon', '杰伦', 'sandy']
names[0:2] = ['李四','春哥',1,2,3]
print(names)　　#结果：['李四', '春哥', 1, 2, 3, 'Andy', 'egon', '杰伦', 'sandy']

查

遍历列表中的每个元素

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
for i in names:
    print(i)#结果：tom
                # [1, 2, 3]
                #Andy
                #egon

切片查找，查找出来仍是一个列表

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
print(names[0:2])　　#结果：['tom', [1, 2, 3]]

公共方法：

len()：长度

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
l = len(names)
print(l)　　#结果：6

count()：计数，返回整数

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
num = names.count('杰伦2')
print(num)　　#结果：1，没有返回0

index()：找到元素的索引

names = ['tom',[1,2,3],'Andy','egon','杰伦','sandy']
print(names.index('Andy'))　　#结果：2，没有该元素会报错

sort()：排序，主要针对数字

#默认正序
li = [1,5,4,7,6,7,3]
li.sort()
print(li)　　#结果：[1, 3, 4, 5, 6, 7, 7]

#反序
li = [1, 5, 4, 7, 6, 7, 3]
li.sort(reverse=True)
print(li)　　#结果：[7, 7, 6, 5, 4, 3, 1]

reverse()：列表反转

li = [1, 5, 4, 7, 6, 7, 3]
li.reverse()
print(li)　　#结果：[3, 7, 6, 7, 4, 5, 1]

列表的方法嵌套

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
print(infos[1][1])　　#结果：h
infos[1] = infos[1].capitalize()
print(infos)　　　　   #结果：['Andy', 'Zhangsan', '李四', '王五', 'zhaoliu', ['name', 'age', '89']]

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[2] = 'lisi'
print(infos)　　　　　　#结果：['Andy', 'zhangsan', 'lisi', '王五', 'zhaoliu', ['name', 'age', '89']]

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[2] = infos[2].replace('四','日天')
print(infos)　　　　　　#结果：['Andy', 'zhangsan', '李日天', '王五', 'zhaoliu', ['name', 'age', '89']]

将name全变成大写

infos = ['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['name','age','89']]
infos[-1][0] = infos[-1][0].upper()
print(infos)　　　　　　#结果：['Andy', 'zhangsan', '李四', '王五', 'zhaoliu', ['NAME', 'age', '89']]

1七、元组

元组又称只读（儿子不能改，孙子可能能够改）列表可循环，可查询，可切片

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
print(infos[3])    #结果：zhangsan,可查
print(infos[0:4])  #结果：(1, 2, 3, 'zhangsan'),可切片,切片以后仍是元组
for i in infos:    #结果：1
    print(i)            #2
                        #3
                        #zhangsan
                        #[2, 3, 4, 'lisi']
                        #Wangwu,可循环

把lisi改为大写（孙子可能能够改），由于孙子有可能不是元组

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
infos[4][-1] = infos[4][-1].upper()
print(infos)　　　　#结果：(1, 2, 3, 'zhangsan', [2, 3, 4, 'LISI'], 'Wangwu')

append()：追加

infos = (1,2,3,'zhangsan',[2,3,4,'lisi'],'Wangwu')
infos[4].append('赵六')
print(infos)　　　　#结果：(1, 2, 3, 'zhangsan', [2, 3, 4, 'lisi', '赵六'], 'Wangwu')

join()：可迭代的对象

用法：‘用什么分割（字符）’.join(可迭代对象)

s = 'zhangsan'
s1 = '+'.join(s)
print(s1)　　#结果：z+h+a+n+g+s+a+n

列表------》字符串用 join()

names = ['tom','Andy','egon','杰伦','sandy']
s = ''.join(names)
print(s)　　#结果：tomAndyegon杰伦sandy

字符串------》列表用 split()

range()，里面加范围，能够当作是一个列表

print(type(range(1,100)))
for i in range(90,100):
    print(i)　　　　#结果：打印90-99
for i in range(90,100,3):
    print(i)　　　　#结果：打印90，93,96,99
for i in range(10,0,-1):
    print(i)　　　　#结果：打印10-1
for i in range(0,10,-1):    #不会报错
    print(i)　　　　#结果：不显示
for i in range(10, -1):  # 不会报错
    print(i)　　　　#结果：不显示
for i in range(10,-1,-1):  # 包括0
    print(i)　　　　#结果：10-0

变量总体的概念

a, b = [1, 2]
print(a, b)　　　　　　#结果：1 2
a, b = [1, 2], [2, 3]
print(a, b)　　　　　　#结果：[1, 2] [2, 3]
a, b = (3, 4)
print(a, b)　　　　　　#结果：3 4

a,b = 1,2　　
print(a,b)　　　　　　#结果：1 2
#面试题：一行代码转换ab的值
a,b=b,a
print(a,b)　　　　　　#结果：2 1

1八、字典

字典：惟一的映射类型，以键值对组成
　　　　dict 的 key 必须是不可变数据类型，可哈希
　　　　 value：任意数据类型
　　dict 优势：二分查找去查询
　　　　　　储存大量的关系
　　特色：无序的（3.5之前的版本）
　　数据类型划分：可变数据类型和不可变数据类型
　　　　不可变数据类型：
　　　　　　　　　　　　元组，bool值，int，str（对str的各类操做都会造成新的str），
　　　　　　　　　　　　不可更改又叫可哈希
　　　　可变数据类型：
　　　　　　　　　　　　列表list，字典dict，集合set
　　　　　　　　　　　　又叫不可哈希

字典的定义

dic = {
    'name': ['张三','李四'],              # str--->list
    'class': [{'num':71,'avg_age':18}],  # str--->list--->dict
    True: 1,                             # bool---->int
    (1, 2, 3): '无心义',                  # 元组--->str
    1: '大哥'                             # int--->str
}
print(dic)#结果：{'name': ['张三', '李四'], 'class': [{'num': 71, 'avg_age': 18}], True: '大哥', (1, 2, 3): '无心义'}

增（2种）

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1['high'] = 185  #没有键值对添加
dic1['age'] = 16    #若是有键，则覆盖
print(dic1)#结果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185}

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.setdefault('weight')       #默认是None
print(dic1)#结果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185, 'weight': None}
dic1.setdefault('weight', 150)  #原来有键的话不覆盖，没有的话添加
print(dic1)#结果：{'age': 16, 'name': 'zhang', 'sex': 'male', 'high': 185, 'weight': None}

删（4种）（尽可能用pop()）

①pop(),按键删除

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.pop('age'))  #有返回值，字典的键相似于列表的索引
print(dic1)                   #结果：18
# dic1.pop(dage')       # 若是没有，会报错
# print(dic1)                 #结果：{'name': 'zhang', 'sex': 'male'}
dic1.pop('dage',None)   # 不知道有没有的状况下，防止报错
print(dic1)　　　　　　　　　　　 #结果：{'name': 'zhang', 'sex': 'male'}
print(dic1.pop('大哥','没有此键'))    #结果：没有此键；可写一个提示，可设置返回值。若是有键则返回该键对应的值
print(dic1)   　　　　　　　　　　　　　#结果：{'name': 'zhang', 'sex': 'male'}

②popitem()，随机删除

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.popitem()
print(dic1)             #结果：{'age': 18, 'name': 'zhang'}。随机删除，没有意义，现今的版本通常默认删除最后一个
print(dic1.popitem())   #结果：('name', 'zhang')；返回元组，删除的键值

③clear()，清空字典

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1.clear()
print(dic1)             #结果：{}

④del，删除键值，和整个字典

dic1 = {'age':18,'name':'zhang','sex':'male'}
del dic1['name']      # 有的话删除，没有的话报错
print(dic1)           #结果：{'age': 18, 'sex': 'male'}
# del dic1['name1']
# print(dic1)
del dic1
print(dic1)           #结果：报错，由于不存在dic1

改（在增的时候的覆盖自己就是一种改）

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic1['age'] = 16
print(dic1)#结果：{'age': 16, 'name': 'zhang', 'sex': 'male'}

update（）,对原字典进行覆盖该更新

dic1 = {'age':18,'name':'zhang','sex':'male'}
dic2 = {'name':'alex','weight':75}  #有相同的键不变，没有的键更新
dic2.update(dic1)
print(dic1)#结果：{'age': 18, 'name': 'zhang', 'sex': 'male'}
print(dic2)#结果：{'name': 'zhang', 'weight': 75, 'age': 18, 'sex': 'male'}

查

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.keys(),type(dic1.keys()))    #结果：dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>；返回值当作列表
print(dic1.values(),type(dic1.values()))#结果：dict_values([18, 'zhang', 'male']) <class 'dict_values'>
print(dic1.items(),type(dic1.items()))  #结果：dict_items([('age', 18), ('name', 'zhang'), ('sex', 'male')]) <class 'dict_items'>；列表里面是元组，元组里面是键值

dic1 = {'age':18,'name':'zhang','sex':'male'}
value1 = dic1['name']
print(value1)　　　　　　　　　　#结果：zhang
# value1 = dic1['name1']  　　#没有这个值会报错
# print(value1)

get()，首选get

dic1 = {'age':18,'name':'zhang','sex':'male'}
print(dic1.get('name'))
print(dic1.get('name1'))    #结果：None；没有的话不会报错，会返回None
print(dic1.get('name1','没有这个键'))    #结果：没有这个键；能够返回自定义的信息

遍历字典的键值

dic1 = {'age':18,'name':'zhang','sex':'male'}
for i in dic1:
    print(i)　　　　#结果：age，name,sex;什么都不写。默认打印的是键
for i in dic1.keys():
    print(i)　　　　#结果：age，name,sex
for i in dic1.values():     #打印值
    print(i)　　　　#结果：18,zhang,male

items()：返回能够遍历的（键，值）元组数组

dic1 = {'age':18,'name':'zhang','sex':'male'}
for i in dic1.items():
    print(i)#结果：('age', 18)
                # ('name', 'zhang')
                # ('sex', 'male')

去括号，打印键值

dic1 = {'age':18,'name':'zhang','sex':'male'}
for key, value in dic1.items():
    print(key, value)#结果：age 18
                            # name zhang
                            # sex male