Python基础笔记

计算机基础：

　　Cpu（中央处理器）：相当于人的大脑，用于计算。

　　内存：储存数据，4\8\16\32G，成本高，断电即消失。

　　硬盘：1T，固态（速度快）\机械硬盘，储存数据，长久保持的重要文件，小电影等等。

　　操作系统：

　　应用程序：

Python历史：

　　宏观上：Python2与Python3的区别：

　　　　1. Python2源码不标准，混乱，重复码太多，

　　　　2. Python3统一标准，取出重复码。

Python的环境：

　　编译型：一次性将所有程序编译成二进制文件。

        　   优点：运行速度快。

　　　　缺点：开发效率低，不能跨平台。

　　　　使用语言：c，c++等。

　　解释型：当程序执行时，一行一行的解释。

        　　优点：开发效率高，可以跨平台。

        　　缺点：运行速度慢。

        　   使用语言：python，php等。

Python的种类：

　　运行第一个py文件：

   　　　 Python3x：Python 文件路径 回车。

    　　　Python2x：Python2 文件路径 回车。

    　　　宏观区别：Python2x源码，重复率高，不规范，默认编码方式是ASCII码。

          　　　　　　 解决方式：在文件的首行输入：#-*- encoding:utf-8 -*-解决python2中文报错。

　　　　Python3默认编码方式是utf-8。

-*- encoding:utf-8 -*-
print('我爱中国')

Python中的变量：

　　定义：就是将一些运算的中间结果暂存到内存中，以便后续代码调用。

x=1+2+3+4
print(x)
print(x*5)
y=x*5
print(y+100-45+2)

print('泰哥泰哥，我是小弟')
print('泰哥泰哥，我是三弟小妹')

　　规范：1.必须由数字，字母，下划线任意组合，且不能数字开头。

     　　　  2.不能是python当中的关键字。

　　　　    [‘and’,’as’,’assert’,’break’,’class’,’continue’,’def’,’del’,’elif’,’else’,’except’,’exec’,’finally’,’for’,

　　　　    ’from’,’global’,’if’,’import’,’in’,’is’,’lambda’,’not’,’or’,’pass’,’print’,’raise’,’return’,’try’,’while’,’with’,’yield’]

　　　　　3.变量具有可描述性。

　　　　　4.不能是中文，对大小写敏感

　　　　　5.可以多变量赋值。eg：a = b = c = 1或者a,b,c = 1,2.3,"abc"

　　　　　6.可以使用del关键字删除对象。eg：del a

s=1234
12 #10r=3
w*e=4
#print=3

t-t = 2
3t_t = 23
*r = 4
_ = 'fdsa'
___ = 4
%- = 'fdsa'
2w = 5
qwe-r = 'wer'
kfdsdlafhsdakfhdsakdfjkhsdakf = '太白'
print(名字)
AgeOfOldboy = 56
NumberOfStudents = 80

#下划线
age_of_oldboy = 56
number_of_students = 80

Python中的常量：

　　定义：一直不变的量，全部为大写字母。（BIR_OF_CHINA = 1949）

ge1 = 12 
age2 = age1
age3 = age2
age2 = 100
age3 = 5
print(age1,age2,age3) #12, 100 ,100
                      #12,12,12,
                      #12,100,12
                      #100,100,100,

Python中的注释：

　　方便自己，方便他人理解代码。

　　单行注释：#

　　多行注释：’’’被注释内容’’’/””” 被注释内容”””。

用户交互：input

　   1.等待输入。

　　2.将你输入的内容赋值给前面变量。

　　3.Input出来的数据类型全部是str。

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

函数：

　　def 函数名(参数列表):

　　　　函数体

eg1:
def hello(str):
    print("hello:%S"%(str))
hello("Tom")

eg2:
def function01(a,b):
    return a + b
print(function01(3,4))

eg3:
def function02(a = 0,b = 0):
    return a * b
print(function02())
print(function02(3))
print(function02(5,9))

　　变量作用域：

　　　　L（local）局部作用域

　　　　E（Enclosing）闭包函数外的函数中

　　　　G（Global）全局作用域

　　　　B（Built-in）内建作用域

x = int(32)    #内建作用域
g_a = 0    #全局作用域
def function03():
    0_3 = 1    #闭包函数外的函数中
    def function04():
        i_b = 3    #局部作用域

模块：

　　模块是包含所有定义的函数和变量的文件，其后缀名是：.py

import sys
print(sys.path)

流程控制If循环：

#第一种：
if 4 > 5 :
    print('我请你喝酒')
print('喝什么酒')

#第二种：
if 4 > 5:
    print('我请你喝酒')
else:
    print('喝什么酒')

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

score = int(input("输入分数:"))
if score > 100:
    print("我擦，最高分才100...")
elif score >= 90:
    print("A")
elif score >= 60:
    print("C")
elif score >= 80:
    print("B")
elif score >= 40:
    print("D")
else:
    print("太笨了...E")

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

流程控制while循环：

　　While 条件：

                  循环体

print('111')
while True:
    print('我们不一样')
    print('在人间')
    print('痒')
print('222')

#从1--100 
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

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

　

　　　　　无限循环：

                  终止循环：1.改变条件，使其不成立。

                     　　　　 2.break。

#break
print('11')
while True:
    print('222')
    print(333)
    break
    print(444)
print('abc')

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

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

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

　　while else:

　　　　当while循环被break打断，就不会执行else的结果。

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

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

　　continue：结束本次循环，继续下次循环。

for循环：

eg：1
s = 'fhdsklfds'
for i in s:
print(i)

eg：2
s = 'fdsa苍井空fdsalk'
if '苍井空' in s:
    print('您的评论有敏感词...')

格式化输出%：

　　%占位符，s：字符串，d：digit 数字.

　　%%只是单纯的显示%.

#格式化输出：
# % s d
eg；1
name = input('请输入姓名')
age = input('请输入年龄')
height = input('请输入身高')
msg = "我叫%s，今年%s，身高%s" %(name,age,height)
print(msg)

eg：2
name = input('请输入姓名')
age = input('请输入年龄')
job = input('请输入工作')
hobbie = input('请输入爱好')

msg = '''----------info of %s-----------
Name   : %s
Age      : %d
Job       : %s
Hobbie : %s
-------------end--------------''' %(name,name,int (age),job,hobbie)
print(msg)

name = input('请输入名字')
age = input('请输入年龄')
height = input('请输入身高')
msg = "我叫%s,今年%s，身高%s,学习进度3%%" %(name,age,height)
print(msg)
（想要早格式化输出中单纯的%，就再加一个%）

编码：

　　电脑的传输，还有储存的实际上都是0101010101

　　美国：ASCII码，为解决全球化文字问题，创建了一个万国码：unicode。

　　　最开始：

　　　　1个字节：表示所有的英文，特殊字符，数字等等。

　　　　2个字节，16位表示一个中文，不够，unicode一个中文用4个字节表示，32位。

　　　　eg：你   00000000 00000000 00000000 00000100

　　　升级版：utf-8，一个中文用3个字节表示。

　　　gbk国内使用，一个中文用2个字节。

　　python2：

　　　ascii码：A：00000010 8位 一个字节

　　　unicode：A：00000000 00000001 00000010 00000100 32位 四个字节

　　　　　　　  中：00000000 00000001 00000010 00000110 32位 四个字节

　　　utf-8：A：00100000 8位 一个字节

　　　　　　中：00000001 00000010 00000110 24位 三个字节

　　　gbk：A：00000110 8位 一个字节

　　　　　  中：00000010 00000110 16位 两个字节

　　　1.各个编码之间的二进制，是不能互相识别的，会产生乱码。

　　　2.文件的存储、传输，不能是unicode（只能是utf-8、utf-6、gbk、gb2312、ASCII码等）

　　python3:　　　

　　　str 在内存中是用unicode编码。

　　　　bytes类型

　　　　　对于英文：

　　　　　　str：表现形式：s = 'alex'

　　　　　　　　 编码方式： 010101010 unicode

　　　　　　bytes：表现形式：s = b'alex'

　　　　　　　　　 编码方式： 000101010 utf-8 gbk。。。。

　　　　　对于中文：

　　　　　　str：表现形式：s = '中国'

　　　　　　　 　编码方式： 010101010 unicode

　　　　　　bytes：表现形式：s = b'x\e91\e91\e01\e21\e31\e32'

　　　　　　　　 编码方式： 000101010 utf-8 gbk。。。。

eg：1
s = 'alex'
s1 = b'alex'
print(s,type(s))
print(s1,type(s1))
eg：2
s = '中国'
print(s,type(s))
s1 = b'中国'
print(s1,type(s1))
eg：3
s1 = 'alex'        #encode 编码，如何将str --> bytes, ()
s11 = s1.encode('utf-8')
s11 = s1.encode('gbk')
print(s11)
s2 = '中国'
s22 = s2.encode('utf-8')
s22 = s2.encode('gbk')
print(s22)

运算符：

　　赋值运算符：=、+=、-=、*=、/=、%=、**=、//=

　　逻辑运算符：&&、||、！

　　位运算符：&、|、^、~、<<、>>

　　成员运算符：in、not in

　　身份运算符：is、is not

#and or not
#优先级，（）> not > and > or
# print(2 > 1 and 1 < 4)
# print(2 > 1 and 1 < 4 or 2 < 3 and 9 > 6 or 2 < 4 and 3 < 2)

# print(3>4 or 4<3 and 1==1)  # F
# print(1 < 2 and 3 < 4 or 1>2)  # T
# print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)  # T
# print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  # F
# print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)  # F
# print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F

#ps  int  ----> bool   非零转换成bool True   0 转换成bool 是False
# print(bool(2))
# print(bool(-2))
# print(bool(0))
# #bool --->int
# print(int(True))   # 1
# print(int(False))  # 0

'''x or y x True，则返回x'''
# print(1 or 2)  # 1
# print(3 or 2)  # 3
# print(0 or 2)  # 2
# print(0 or 100)  # 100
# print(2 or 100 or 3 or 4)  # 2
# print(0 or 4 and 3 or 2)  #3

'''x and y x True，则返回y'''
# print(1 and 2)
# print(0 and 2)
print(2 or 1 < 3)  #2
print(2 or 1 < 3 and 2)  #2
print(3 > 1 or 2 and 2)  #True
print(1 > 2 and 3 or 4 and 3 < 2)  #False

数据类型分析：

　　int：1，2，3用于计算。

　　数字：int、float、bool、comlix（复数）

　　　　   +、-、*、/、**（幂次方）、%（取余）

　　　　  Ps：type( )函数用了查询变量所指类型

   　　      　　字符串转化成数字：int(str) 条件：str必须是数字组成的。

    　　   　　  数字转化成字符串：str(int)

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

i = 2
print(i.bit_length())
'''
                          bit_length
1     0000 0001        1
2     0000 0010        2
3     0000 0011        2
'''

　　bool：True，False，用户判断。

1 print(True,type(True))
2 print('True',type('True'))

#bool  True False

#int ----> str
i = 1
s = str(i)
#str ---> int
s = '123'
i = int(s)

#int ---->bool：0为False，非0为True
i = 3
b = bool(i)
print(b)
#bool----> int
#True   1
#False  0
'''
ps:
while True:
    pass
while 1: 效率高
    pass
'''

#str --->bool
#s = "" -----> False
#非空字符串都是True
#s = "0" -----> True
s
if s:
     print('你输入的为空，请重新输入')
else:
     pass

　　str：存储少量数据，进行操作。

　　　　'fasda'，'二哥'，'24321'，'张三，李四，王五，赵六，······'

　　字符串：stràpython当中凡是使用引号引起的都是字符串，python中没有字符类型

　　　　可相加：字符串的拼接。

　　　　可相乘（与数字）：str * int

　　　　字符串中插入其它字符串。eg：print(str1[:3] + "123" + str1[3:])

　　　　　　中括号用来截取字符串，下标从0开始

　　　　字符串格式化。eg：print('ABCDEFG%d' %(12345))

　　　　　　%d转义字符

print(1)
print("jsdfdsfsadl;fjdsal;j")
print("I'm a teacher")

a = '泰哥'
b = '小二'
c = a + b
print(c)
print('泰哥' + '小二' +'货')
print('坚强'*8)

msg = """
今天我想写首小诗，
歌颂我的同桌，
你看他那乌黑的短发，
好像一只炸毛鸡。
"""
#print(msg)

#字符串的索引与切片
s = 'ABCDLSESRF'
#索引
#从前往后：
s1 = s[0]
print(s1)
s2 = s[2]
print(s2)
#从后往前：
s3 = s[-1]
print(s3)
s4 = s[-2]
print(s4)
#ABCD   切片 ：顾头不顾尾
s5 = s[0:4]
print(s5)
s6 = s[0:-1]
print(s6)
s7 = s[:]
s8 = s[0:]
print(s7,s8)  s7与s8相同
s9 = s[0:0]
#s[首:尾:步长]
s10 = s[0:5:2]
print(s10)
s11 = s[4:0:-1]
print(s11)
s12 = s[3::-1]
print(s12)
s13 = s[3::-2]
print(s13)
s14 = s[-1::-1]
print(s14)
s15 = s[::-1]
print(s15)

#字符串的操作
s = 'alexWUsir'
s1 = s.capitalize()  # 首字母大写
print(s1)
# 全大写，全小写
s2 = s.upper()
s21 = s.lower()
print(s2,s21)
eg：
s_str= 'acEQ1'
you_input =input('请输入验证码，不区分大小写')
if s_str.upper() == you_input.upper():
    print('输入成功')
else:
    print('请重新输入')
# 大小写翻转
s3 = s.swapcase()
print(s3)
# 每个隔开(特殊字符或者数字)的单词首字母大写
s = 'alex*egon-wusir'
s4 = s.title()
print(s4)
s = 'fade,crazy*w4rri0r_songsong node_3'
s4 = s.title()
print(s4)
#居中，空白填充
s = 'alexWUsir'
s5 = s.center(20,'~')
print(s5)
s = 'alex\tsir'
s6 = s.expandtabs()
print(s6)
#公共方法
s = 'alex二哥'
l = len(s)
print(l)
#以什么开头结尾 endswith
s = 'alexWUsir'
s7 =s.startswith('alex')
s71 = s.startswith('e',2,5)
print(s71)
'''
if s7:
    pass
elif s.startswith('bl'):
    pass
print(s7)
'''
# find：通过元素找索引，找到返回下标值，找不到返回-1。
# index：通过元素找索引，找到返回下标值，找不到报错。
s = 'alexWUsir'
s8 = s.find('A')
s81 = s.index('A')
print(s81,type(s8))
#strip，rstrip，lstrip
s = 'alexWUsir%'
s9 = s.strip('%')
print(s9)
s = ' *a%lexWUsi* r%'
s91 = s.strip(' %*')
print(s91)
# strip：默认删除前后空格
username = input('请输入名字：').strip()
if username =='春哥':
print('恭喜春哥发财')
s = 'alexaa wusirl'
s10 = s.count('al')
print(s10)
# split   str ---->list
s = ';alex;wusir;taibai'
l = s.split('a')
print(l)
# format的三种玩法，格式化输出
s = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('太白',36,'girl','太白')
print(s)
name = input('请输入名字：')
s = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format(name,36,'girl')
print(s)
name = input('请输入名字：')
s = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(age=18,name=name,hobby='girl')
print(s)
# replace：替换
s = '来看待街坊邻居复合大师街坊法好的撒见客户'
s11 = s.replace('街坊','老王',1)
print(s11)
# is系列
name = 'jinxin123'
print(name.isalnum())   #字符串由字母或数字组成
print(name.isalpha())    #字符串只由字母组成
print(name.isdigit())      #字符串只由数字组成

　　list：储存大量的数据。

　　　　[1，2，3，'泰格'，'12353234'，[1，2，3]]

　　元祖：只读（只能看，不能修改）。

　　　　(1，2，3，'第三方'，)

　　dict：字典{'name':'云姐','age':16}

　　　　  字典{'云姐':[],'二哥':[200,200,200,······]}

　　集合：{1,2,3,435,'reter'}

列表list：

　　列表相当于字符串，可存储不同数据类型，也可存储大量数据，且列表是有序的，有索引值，可切片，方便取值。

　　增 append insert extend
　　删 remove pop clear del
　　改 li[索引] = '被修改的内容' li[切片]：'被修改的内容'
　　查 for循环
　　　 range

eg：1
li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
l1 = li[0]
print(l1)
l2 = li[1]
print(l2)
l3 = li[0:3]
print(l3)

li = ['alex','wusir','egon','女神','taibai']
#增 append、insert
eg：2
li.append('日天')
li.append(1)
print(li)
eg：3
while 1:
    username = input('>>>')
    if username.strip().upper() == 'Q':
        break
    else:
        li.append(username)
print(li)
eg：4
li.insert(4,'春哥')
print(li)
eg：5
li.extend('二哥')
li.extend([1,2,3])
print(li)
#删
eg：6 # 按索引去删除
name = li.pop(1)  # 返回值
name = li.pop()  # 默认删除最后一个
print(name,li)
eg：7 # 按元素去删除
li.remove('taibai')
print(li)
eg：8 # 清空
li.clear()
print(li)
eg：9 # 删除整个表
del li
print(li) # 结果报错（无列表，没有定义，所以报错）
eg：10 # 按切片去删除
del li[0:2]
print(li)
#改
eg：11
li[0] = '男兽'
li[0] = [1,2,3]
# 按切片去改
li[0:3] = '云姐plfdslkmgdfjglk' 
print(li)  # 结果分成最小元素
# 按索引去改
li[0:3] = [1,2,3,'春哥','咸鱼哥']
print(li)
#查
eg：12
for i in li:
    print(i) # 查表中的所有元素
print(li[0:2]) # 按切片查前两个元素
#公共方法：
eg：13
l = len(li)
print(l)
num = li.count('taibai')
print(num)
print(li.index('wusir'))
# 排序
li = [1,5,4,7,6,2,3]
eg：14
#正向排序
li.sort()
print(li)
#反向排序
li.sort(reverse=True)
print(li)
#反转
li.reverse()
print(li)
#列表的嵌套
li = ['taibai','武藤兰','苑昊',['alex','egon',89],23]
eg：15
print(li[1][1])
name = li[0].capitalize()
li[0] = name
li[0] = li[0].capitalize()
eg：16  将‘苑昊’改为‘苑ritian’
方法一：
li[2] = '苑日天'
print(li)
方法二：
print(li[2].replace('昊','ritian'))
li[2] = li[2].replace('昊','ritian')
eg：17 # 将alex改为大写
li[3][0] = li[3][0].upper()
print(li)

元祖tupe：

　　只读列表，数据可以被查询，但不能被修改，字符串的切片操作同样适用于元祖。

　　儿子不能更改，孙子可更改。　

　　count()                           #元素出现次数
　　len()　　　　　　　　   #长度
　　li.index('元素')　　　　  #查找索引
　　sort（reverse = True）  #倒叙排序
　　li.sort()　　　　　　　   #正序排序
　　print(li.sort())
　　reverse()反转
　　ps:
　　　　join: list ----->str
　　　　　　S.join(iterable)
　　　　　　　　li = [1,2,3]
　　　　　　　　s1 = str(li)
　　　　split str---->list

tu = (1,2,3,'alex',[2,3,4,'taibai'],'egon')
eg：1
#查
print(tu[3]) 
print(tu[0:4]) # 切片查询
for i in tu:
    print(i)
eg：2 
#将‘taibai’改为大写
tu[4][3]=tu[4][3].upper()
print(tu)
eg：3
#在列表中‘taibai’之后添加‘sb’
tu[4].append('sb')
print(tu)
eg：4
#join（可迭代对象）
s = 'alex'
s1 = '-'.join(s)
print(s1)
#列表转化成字符串  list -----> str    join
#字符串转化成列表  str ----->list     split()
li = ['taibai','alex','wusir','egon','女神',]
s = '++++'.join(li)
print(s)
eg：5
#range  [1,2,3,4,5,6,.......100........]
  按数字排列的顺序列表
从3开始：
for i in range(3,10):
    print(i)
从0开始：
for i in range(10):
    print(i)
步长：
for i in range(0,10,3):
    print(i)
for i in range(10,0,-2):
    print(i)
for i in range(0,10,-1):   #结果不出，什么都没有，不会报错
    print(i)
for i in range(10,-2):      #结果不出，什么都没有，不会报错
    print(i)
for i in range(10,-1,-2):
    print(i)
eg：6
li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']
#循环打印列表：
for i in li:
    if type(i) == list:
        for k in i:
            print(k)
    else:print(i)

for i in range(len(li)):
    if type(li[i]) == list:
        for j in li[i]:
            print(j)
    else:print(li[i])

字典dict：唯一一个映射类型

　　数据类型划分：可变数据类型与不可变数据据类型

　　　　可变数据类型（不可哈西）：list，dict，set

　　　　不可变数据类型（可哈西）：元祖，bool值，int（数字），str（字符串）

　　字典的key（键）必须是不可变数据类型，可哈西，

　　　　value：任意数据类型。

　　优点：使用二分查找去查询

　　　　　存储大量的关系型数据

　　特点：无序的（3.5版本（包括3.5）前都是无序的）

#字典建立
dic = {
    'name':['大猛','小孟'],
    'py9':[{'num':71,'avg_age':18,},
           {'num': 71, 'avg_age': 18, },
           {'num': 71, 'avg_age': 18, },
           ],
    True:1,
    (1,2,3):'wuyiyi',
    2:'二哥',
}
print(dic)

dic1 = {'age': 18, 'name': 'jin', 'sex': 'male',}
#增：setdefault
eg：1
dic1['high'] = 185  #没有键值对，添加值
dic1['age'] = 16  #有键值对，则值覆盖
eg：2
setdefault   #有键值对，不做任何改变，没有才添加
dic1.setdefault('weight')  #无值时，默认为none
dic1.setdefault('weight',150)
dic1.setdefault('name','二哥')
print(dic1)

#删：pop、popitem、del、clear
eg：3
print(dic1.pop('age'))   #有返回值，按键去删除
print(dic1.pop('二哥'))   #无键时报错
print(dic1.pop('二哥',None))   #可设置返回值
print(dic1.popitem())  #随机删除，有返回值：元组里面是删除的键值。
del dic1['name']   #删除键值
print(dic1)
del dic1   #删除字典，结果报错，原因：字典被删除
print(dic1)
dic1.clear() #清空字典

#改：update
eg：4
dic1['age'] = 16   #键值覆盖
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  #将dic所有键值对更新到dic2中（更新覆盖）
print(dic)
print(dic2)

#查
eg：5
print(dic1.keys(),type(dic1.keys()))   #结果内容：键
print(dic1.values())   #结果内容：值
print(dic1.items())   #结果内容：元祖（键，值），并不是键值对
for i in dic1:   #设置变量i时，什么都不写，默认打印结果为键
    print(i)
for i in dic1.keys():    #打印键
    print(i)
for i in dic1.values():    #打印值
    print(i)
for i in dic1.items():    #打印键值对
    print(i)

eg：6
1）分别赋值：
a,b = 1,2
print(a,b)
2）使用一行代码转化a、b的值：
a = 1
b = 2
a,b = b,a
print(a,b)
3）最小单位一一对应，分别赋值：
a,b = [1,2],[2,3]
a,b = (1,2)
print(a,b)
for k,v in dic1.items():
    print(k,v)

eg：7
v1 = dic1['name']
print(v1)
v2 = dic1['name1']    #无值时报错
print(v2)
print(dic1.get('name1'))    #无值时返回none
print(dic1.get('name1','没有这个键'))    #返回自定义的值

字典dict嵌套：

#字典建立
dic = {
    'name':['alex','wusir','taibai'],
    'py9':{
        'time':'1213',
        'learn_money':19800,
        'addr':'CBD',
           },
    'age':21
}
dic['age'] = 56    #age改为56
print(dic['name'])
dic['name'].append('ritian')    #列表中添加人名‘ritian’
print(dic)
dic['name'][1] = dic['name'][1].upper()    #将‘wusir’全部变为大写
print(dic)
female : 6    #给py9添加一个键值对：female : 6
dic['py9']['female'] = 6
print(dic)

# fhdklah123rfdj12fdjsl3    '123、12、13'
    使用debugger运行处理：
info = input('>>>').strip()
for i in info:
    if i.isalpha():
        info = info.replace(i," ")
l = info.split()
print(len(l))

 小知识点汇总：

　　1.python2与python3的区别：

　　　python2：

       　　print可加括号，也可不加括号；有range()，也有xrange()[生成器]；用户输入：raw_input()

      　 python3：

　　　　print必须加括号;只有range();input()

python2
print()  print 'abc'（可以加括号，也可不加）
range()   xrange() 生成器
raw_input()

python3
print('abc')（必须加括号）
range()
input()

　　2.=：赋值； ==：比较值是否相等； is：比较（比较的是内存地址）  id（内容）

eg：1
li1 = [1,2,3]
li2 = li1
print(li1 is li2)    #结果为TRUE
eg：2
li1 = [1,2,3]
li2 = li1
li3 = li2
print(id(li1),id(li2))    #结果相同

　　3.数字，字符串：存在“小数据池”概念（为了节省空间）

　　　数字的范围 -5 -- 256

　　　字符串：1：不能有特殊字符

　　　　　　　2：s*20 还是同一个地址，s*21以后都是两个地址

eg：1
i1 = 6
i2 = 6
print(id(i1),id(i2))    #结果相同
eg：2
i1 = 300
i2 = 300
print(id(i1),id(i2))    #结果不同

　　4.剩下的list、dict、tuple、set无“小数据池”概念

eg：1
l1 = [1,]
l2 = [1,]
print(l1 is l2)
eg：2
s = 'alex'
s1 = b'alex'
print(s,type(s))
print(s1,type(s1))
eg：3
s = '中国'
print(s,type(s))
s1 = b'中国'
print(s1,type(s1))

集合及深浅copy：

　　集合：可变数据类型，但里面的元素必须是不可变的数据类型（），集合是无序的，不重复。

　　　　　{}无键值对

set1 = set({1,2,3})
set2 = {1,2,3,[2,3],{'name':'alex'}}  # 错的
print(set1)
print(set2)

set1 = {'alex','wusir','ritian','egon','barry',}
增：add、update
eg：1
set1.add('女神')
print(set1)
eg：2
set1.update('abc')
print(set1)
删除：pop、remove、clear、del
eg：1
set1.pop()            # 随机删除
print(set1.pop())  # 有返回值
print(set1)
eg：2
set1.remove('alex')  # 按元素
print(set1)
eg：3
{}：空字典             set()：空集合
set1.clear()
print(set1)
eg：4                       #删除整个集合
del set1
print(set1)
查：for i in
for i in set1:
    print(i)
交集：
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
set3 = set1 & set2
print(set3)                               # {4, 5}
print(set1.intersection(set2))  # {4, 5}
并集：
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)           # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}
反交集：
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)                                  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}
差集：set1独有的
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)                  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}
子集与超集：
set1 = {1,2,3,}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2))     #这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1))  #这两个相同，都是说明set2是set1超集。
去重：
li = [1,2,33,33,2,1,4,5,6,6]
set1 = set(li)
print(set1)
li = list(set1)
print(li)
s1 = {1,2,3}
print(s1,type(s1))
frozenset不可变集合，让集合变成不可变数据类型：
s = frozenset('barry')
print(s,type(s))
for i in s:
    print(i)