python入门知识总结1

博主学习过C语言和C++，在学校寒假期间第一次接触python，利用书写博客，来整理当天所学，方便后期的复习和回顾，在这个过程中会不断的进行学习和补充
以下文章根据博主在中国大学MOOC上的陈斌教授的网课学习整理

1.python程序的主要特征以及和C与C++差别

————————————————————————————————————————

• 值得注意的是，python和C和C++不相同的时，它不再有一个一个有括号框起来的函数体，而是由各个语句的缩进格数来判断是不是属于同一个函数，如下列函数所示

if   x>3：
		return x
return y

在if控制的条件下，仅有‘return x’的条件存在，而return y 并不在if控制的范围之内。因此可知在python中，语句的缩进有着至关重要的作用。

• 同时可以发现与C和C++不同的是，if后面的执行条件不再有括号，且有些语句（如if，else，while）的末尾是有冒号的。
• 在C语言和C++中的注释常用//或者/* */，在python中用#来注释内容，在pycharm中可用快捷键 “ctrl+/ ”快速实现。注释后的语句对程序没有影响，在编程中，要养成加注释的习惯。
• 在函数的写法方便有区别，如print和printf，如scanf和input，且print自带回车。
• 在书写代码的形式上，我们可以发现python相对于其他编程语言来说更加简洁，极大的提高了生产力，且可以跨平台，代码的可读性非常高，且软件开源，可以被自由的传播和分享。
• python语言不用特别的关心变量的函数类型，继承了多种优秀语言的特性，是一种高级动态，完全面向对象的语言，函数，模块，数字，字符串都是对象，并且完全支持继承，重载，派生，多继承，有益于增强源代码的复用性。
• python是一个超级计算器，可以直接进行特大数的计算。
• python的语句后不需要加分号
• 总之，python和其他语言而言既有共同点也有区别，以上总结并不是全部，只是简单的介绍一下它们之间的区别，在今后的学习中可以留心观察，对比记忆！*

---

2.Python 各个版本发展历史

• 版本1.x：支持异常处理、函数定义、开发了核心数据结构
• 版本2.x：支持列表解析，垃圾收集器和Unicode编码
• 版本3.x：不向后兼容2.x，扫除了变成结构和模块上的冗余和重复，使之更加的精简
• python3的改变。修改了语法，让print（）成为了内置函数，改进了python2中input（）函数，统一了字符的编码，更新了模块，删除部分果实的模块或者函数，添加了一些新的模块，数据结构dict性能的优化，不再区分整数长整数，统一为int。修改了除法，让其和数学保持一致
• 能与C语言进行对接

---

3.Pycharm使用说明

pycharm相对于python2，3而言更利于开发使用，因此在已经安装python2或者python3的情况下，可以安装pycharm更利于学习和使用。

以下是pycharm在使用时的注意事项：

• 注意对齐和缩进
• 注意字母和大小写，空格
• 在使用时，只需要输入我们所需要的语句，不需要再假如和C语言一样的头文件，如要输出“HELLO WORLD”我们只需要

print("HELLO WORLD")

• 注意左右括号的配对

---

4.数据对象以及其组织

python语言是一种最热门的大数据分析处理语言

整数int、浮点数float、复数complex、逻辑值bool，字符串str
各种类型简介 int表示的是整数类型 它不再像C，C++中分为long、short和int，在python中只有一个整数类型int；同浮点数也不再区分double和float，只有一个float类型；复数complex多用于数学中的复杂运算；逻辑值bool型，仅有两种情况即逻辑真和逻辑假；str就是字符串类型，当然也可以包含一个字符的情况。
不管是哪一种类型，在表示变量类型意义的同时，里面也封装了很多相关的函数，比如字符串型就可以用 type(str)来检验

---

1. 整数类型：int

---

特点

不限制大小，无论多复杂的算是都可以直接得到结果

---

常见的运算

PS:两个int型相除 就会直接转换为float
以及大小比较，连续比较判断

代码

7>3>=3 
TURE
12<23<22 
FLASE

---

数的进制

最常用的是二进制八进制和十六进制来表示整数，使用时只要加一个前缀用以标识几进制即可

拓展练习1：进制的转换

print(hex(33))#十六进制
print(oct(33))#八进制
print(bin(33))#二进制
#输出结果
0x21
0o41
0b100001

拓展练习2：简单计算机的制作

print(eval(input()))

2.浮点类型：float

特点

科学计数法

• 有效位数
  读点类型的计算和整形类似，但是浮点数由17为有效数字的限制

特性

进制转换导致精度误差。因为这个特点 会导致误差的产生，因此判断的是皇后尽量避免相等的判断，只要小于一个很小的误差即可。因此浮点数再也不能用等号来判断，例如两个浮点数A和B,A-B==0就不对了，我们要将它改成A-B<=10^-17就表示两个浮点数相等 。

3. 复数类型：complex

复数生成

python内置复数数据类型

复数运算

支持所有常见运算

复数比较

复数之间只能比较是都相等。复数相当于平面上的两个点，只能判断位置是否相等

数学常数

圆周率Π，自然对数的底e等

数学函数

三角函数、对数，最大公约数，最小公倍数等

更多的数学函数:cmath模块

专门面向复数计算
math模块中的数学函数用于计算整数和浮点数，对于复数就无能为力了
平面直角坐标和极坐标之间的转换

import cmath
cmath.polar(1+1j)#将直角坐标转换为极坐标
(1.4142135623730951, 0.7853981633974483)
cmath.rect(1,cmath.pi/2)#把用极坐标方式表示的转换为平面直角坐标
(6.123233995736766e-17+1j)

import math
dir(math)#运行可以查看math中存在的函数

---

4.逻辑类型：bool/boole

定义

非真即假的二值逻辑，逻辑值仅仅包括真（True）/假（Flase）两个，布尔型本质上也是int类型，可以通过强制转换转换成int

作用

配合if/while等语句做条件判断

逻辑运算

包括与运算（and），或运算（or），非运算（not）

非运算

定义：即为否定操作否定，not连接一个真值，非真即假非假即真，且not要写在值的前面

三种逻辑运算符使用注意事项

1. and和or是双目运算，由两个逻辑类型真值进行运算，not是单目运算，运算符与一个逻辑类型真值相结合。联系记忆：整数中也有单目运算符负号“-”
2. 三个运算符也是有优先级的
   单目运算符not的优先级最高，and次之，or最后。
   一般写的时候隐式的约定最好显性的表达出来，不保证所有的程序员记得，写的时候尽管明白这个逻辑顺序，优先的逻辑结构还是要用括号先框出来。

各种类型对应的真值

1. 整数、浮点数和复数类型。0是假，所有的非0的值都是真
2. 字符串类型。空串是假，所有非空串都是真
3. 所有序列类型（包括字符串）。空序列是假，所有的非空序列都是真。
4. 空值None，表示无意义或者不知道，也是假

---

5.字符串类型:str

文本的表示定义

字符串就是把一个个文字的字符“串起来”的数据。文字字符包括有拉丁字母、数字、标点符号、特殊符号、以及各种语言文字字符，其实发展到现在中文等语言也可以作为字符串中的字符。

表示字符串数值

• 多行字符串用三个连续单引号表示。
• 单引号开始必须单引号结束，双引号开始必须双引号结束。

"sbwgguwgduwhdhwud"
'sbagscagcjhacgacc'
#两种字符串表示形式都可以
'''
ncjabcjabcjhabjcajbc
cnasjkbcjabjkcbakjbc
cdajbcjabcj
'''#多行字符串表示形式，三个连续的单引号或者双引号都可以

• 用双引号或者单引号都可以表示字符串，但必须成对。
  这样就在一定程度上避免了在字符串中本身就存在单引号和双引号的时候的出错的概率。即假如字符串中有单引号时就用双引号，假如字符串中有单引号时用单引号。

那假如字符串中单引号和双引号同时存在呢？
这就引入了新的问题 特殊字符用转移符号“\”表示

• 反斜杠后面带着一个符号时，那么这个字符就当作自己本身字面上的意思来理解，不再作为字符串分界这个方向来使用。所以在字符串中既有双引号也有单引号，那么就可以在字符串中’或者",那么分界时用单引号双引号就都没有问题，那么还有其他的转移符号如上图所示。

如果字符串中本身就存在反斜杠呢？ 那么就用两个反斜杠代表字符串中的一个反斜杠

字符的编号

字符串字符的编号方法

• 第一个字符的编号是0，第二个字符的编号是1，然后以此类推 最后一个字符编号是-1，倒数第二个字符编号是-2

a='cdbscbebchbchb'
print(a[0])
print(a[1])
print(a[-1])
print(a[-2])
#输出结果
c
d
b
h

• 每一个字符都有两个编号，一个是大于等于零的正向编号，一个是小于等于零的反向的编号，两个编号都是可以用的
• 用这个编号方法就可以从字符串中抽取出任何一个字符。
• 字符串是数据本身，名字是数据的标签。名字和字符串是名和值之间的关系，名称之间不能包括特殊字符，一个字符串数值可以关联多个名字，一个名字在同一时刻只能关联一个字符串数值，字符串数值只能是字符串类型，名字可以关联任意类型的数值。

height=8848
mt=everest="珠穆朗玛峰"#可以传递赋值！
#一个数据对象可以挂好几个标签，而一个标签只能挂在一个数据上
print(type(height))
<class 'int'>
print(type(mt))
<class 'str'>

常见的字符串操作

获取字符串的长度：len

len函数

a='sjnjscbj'
print(a.__len__())

关于下划线：一个简单的字符a都有很多的方法支撑，引用方法时，前面有两个下划线，代表是系统中自带的方法。前面有一个表示是自己定义不愿意给别人用的。自己定义的不加下划线。

切片（slice）操作

s[start：end：step] start和end就是我们刚刚说的位置数，整数复数都可以，step就是逐个取值时每次跨过的长度，如果没有step时，它的值就默认为1
且在[start:end]的区间中，实际上它是左闭右开区间，包括start不包括end

a='sjnjscbj'
print(a[::2])
#结果
snsb

利用这种方法还可以进行倒序输出

a='sjnjscbj'
print(a[::-1])
#运行结果
jbcsjnjs

加法乘法：“*”，“+”

“+”将两个字符串进行连接，得到新的字符串

a='sjnjscbj'
b='bdhebhe'
print(a+b)
#运行结果：sjnjscbjbdhebhe

“*”将字符串重复若干次，生成新的字符串

a='abc'
print(a*2)
#运行结果：abcabc

判断字符串内容是否相等（==）
一个等号是赋值语句，两个等号是左右两边的数值判断，判断结果是true或者false
如果是相同的字符串就返回true，否则就返回false

判断字符串中是否包含某个字符串（in）
既可以判断一个字符，也可以判断多个字符

a='bsdegfewgfjewgfg'
print('h'in a)
print('bs'in a)
False
True

删除空格：str.strip，str.lstrip，str.rstrip

str.strip:去掉字符串前后的所有空格，内部的空格不受影响
str.lstrip:去掉字符串前部（左部）的所有空格
str.rstrip:去掉字符串后部（右部）的所有空格

a='   a   b   c    '
print(a.strip())
print(a.lstrip())
print(a.rstrip())
#运行结果
a   b   c    
a   b   c    
   a   b   c    

判断字母数字：str.isalpha，str.isdigit，str.isalnum

str.isalpha:判断字符串是否全部由字母构成
str.isdigit:判断字符串是否全部由数字构成
str.isalnum:判断字符串是都仅包含字母和数字，而不包含特殊字符

a='qwe123 '
print(a.isalpha())
print(a.isdigit())
print(a.isalnum())
#运行结果
False
False
False

二进制码和字符的转换：ord和chr

ord()函数主要用来返回对应字符的ascii码，括号内放的是待转换的字符。
chr()主要用来表示ascii码对应的字符他的输入时数字，可以用十进制，也可以用十六进制，括号内放的是待转换的二进制码数字。

print(ord(' '))
print(chr(97))
#运行结果
32
a

字符串的高级操作

1. split：分割 ； join：合并

spilt就是按照所给的字符对字符串进行分割，如例子所示，就是按照空格对字符串进行分割

print('YOU ARE MY SUNSHINE.'.split(' '))
['YOU', 'ARE', 'MY', 'SUNSHINE.']#经过split的分割，它就变成了一个列表，包含四个单词

而join就是对split的反操作，就是将所给的列表，将其中的字符用所给的字符进行连接

print('-'.join(["ONE","TWO","THREE"]))
ONE-TWO-THREE

2. upper/lower/swapcase:大小写相关

upper 小写变成大写
lower 大写变成小写
swapcase 大小写颠倒

print('abc'.upper())
ABC
print('ABC'.lower())
abc
print('Abc'.swapcase())
aBC

3. ljust/center/rjust:排版左中右对齐

或者可以在一个固定的宽度里，左对齐，右对齐或者居中对齐

print('HELLO WORLD!'.center(20))
#在宽度为20的长度下，字符串居中对齐
    HELLO WORLD!    

4. replace是把字符串中的某个字串的出现换成另外一个

print('Tom smiled, Tom cried, Tom shouted'. replace('Tom','Jane'))
Jane smiled, Jane cried, Jane shouted

序列（sequence）

定义

其实在python中，序列是字符串中的一种特殊的情况。序列的定义是，能够按照整数顺序排列的数据，由于字符串是按照0123排列的字符，故字符串是序列。

序列的内部结构

• 可以通过从0开始的连续整数来索引单个对象
• 可以执行切片，获取序列的一部分 可以用len函数来获取序列中包含多少元素
• 可以用加法来连接为更长的序列 可以用乘法来重复多次，成为更长的序列
• 可以用in来判断某个元素是某在序列中存在，或者子序列是否是序列的一部分
  因此，总的来说概念是通用的，以后碰到的序列的其他结构，其实都和字符串的类似。序列的类型会在后期进行补充。
  列表list、元组tuple，集合set，字典dict

拓展练习3各种数据的强制类型转换

print(int(44.7))
print(bool(1))
print(str(45678))
print(float(9))
#运行结果
44
True
45678
9.0

——————这里是分割线——————其后就是容器型的数据类型———————————

6.列表

定义

• 用来收纳数据对象的数据类型
• 以一种规则的下标索引方式，访问到每一个数据
• 这种收纳盒是一种序列
• 列表可以删除、添加、替换、重排序列中的元素（可变类型）
• 列表的下标顺序从0开始，是连续的
• 列表是一个可变的容器，可以随意增减
• 但并不是所有的数据容器都能够像列表一样可以继续添加新元素

创建列表的方法

• 方括号法[ ]
• 指明类型法list（）

 str1="123456"
list1=[11,2.3,5,6,7]#方括号法
tup1=(123,789,2929)
a=list(str1)#指明类型法
b=list(list1)
c=list(tup1)
print(a,b,c)`

列表和元组中保存的各个数据称作元素，类型没有限制

列表的操作

增长列表：append操作/insert操作/extend操作

append在后面加上一个数据对象，insert在中间加上，extend是拼接

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
member.append('字符串')
member.extend(('1234'))
member.insert(3,'python')#序号从0开始
print(member)
#运行结果
['小甲鱼', 88, '黑夜', 'python', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88, '字符串', '1', '2', '3', '4']

缩减列表：pop操作/remove操作/clear操作

pop指定一个序号，从中间提取出来删除，不带任何序号就是把最后一个移走，
remove就是根据数据对象本身的值来移除的，剩余的对象还是从0开始的排列，但是长度缩减1
clear就是将整个列表变成空列表

pop运行示意

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
member.pop()
print(member)
#运行结果
['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳']

remove运行示意

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
member.remove('小甲鱼')
print(member)
#运行示意
[88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]

clear运行示意

member = ['小甲鱼', 88, '黑夜', 90, '迷途', 85, '怡静', 90, '秋舞斜阳', 88]
member.clear()
print(member)
#运行结果
[]

重新组织:reverse/sort操作和reserved/sorted操作

reverse：把列表中的数据元素从头到尾反转重新排列
sort：把列表中的数据元素按照大小顺序重新排列
reserved/sorted操作:得到重新排序的列表，而不影响原来的列表0
reverse、sort运行示意
reverse

member = [1,9,0,3,4,5]
member.reverse()
print(member)
#运行结果
[5, 4, 3, 0, 9, 1]

sort

member = [1,9,0,3,4,5]
member.sort()
print(member)
#运行结果

以上是sort的一般操作 更加深入的请结合
https://blog.csdn.net/liudsl/article/details/79980625
https://www.cnblogs.com/huchong/p/8296025.html
reversed

a=[12,34,564,424]
b=reversed(a)
print(a)
print(list(b))
#运行结果
[12, 34, 564, 424]
[424, 564, 34, 12]

请看https://www.jb51.net/article/136728.htm
sorted

a=[12,34,564,424]
b=sorted(a)
print(a)
print(b)
#运行结果
[12, 34, 564, 424]
[12, 34, 424, 564]

合并

加法运算+：连接两个列表/元组
乘法运算*：赋值次，生成新列表/元组

a=[12,34,564,424]
b=[1,2,3]
c=a+b
d=a*2
print(c,d)
#运行结果
[12, 34, 564, 424, 1, 2, 3] [12, 34, 564, 424, 12, 34, 564, 424]

列表/元组的大小

len():列表/元组中元素的个数

a=[12,34,564,424]
print(len(a))
#运行结果
4

列表/元组的索引和切片

索引

• alist[n]或者atuple[n]
• 可以用赋值语句给列表中任何一个位置重新赋值
• 但是元组属于不可变类型，索引只能获取对应位置中的数据值，不可重新赋值

s="abcdefghk"
print(s[0])   a
print(s[-1])  k
print(s[2])   c

切片

元组列表操作相同
alist[start: end:step]
atuple[start: end:step]

s="abcdefgh"

print(s[:])   abcdefgh 
print(s[0:])  abcdefgh
print(s[0:-1]) abcdefg
print(s[0:-2]) abcdef
print(s[1:3]) bc
print(s[1:4]) bcd

print(s[0:4]) abcd
print(s[0:0]) 空字符 

print(s[0:5:2]) ace 步长为2 

print(s[4:0:-1]) 从4到0，取倒数值，不顾尾。edcb
 print(s[4::-1])  edcba
 print(s[-1::-1]) hgfedcba
 print(s[:])   abcdefgh
 print(s[::-1]) hgfedcba

查找

in操作：判断某刻元素是否在列表/元组中
index：只当的数据在列表/元组的哪一个位置
count操作：指定的数据在列表/元组中出现过几次
in

a=[12,34,564,424]
b= 12 in a
print(b)
#True

index

a=[12,34,564,424]
b=a.index(12)
print(b)
#0

count

a=[12,34,564,424]
b=a.count(12)
print(b)
#1

计算

• sum函数：将列表中的所有数据元素加和
• min/max函数：返回列表中最小/最大的数据元素

a=[12,34,564,424]
b=sum(a)
print(b)
#1034

sum补充https://www.runoob.com/python/python-func-sum.html
min/max

a=[12,34,564,424]
b=min(a)
c=max(a)
print(b,c)
#12 564

列表的其他方法

7.元组

定义

• 元组是不能再更新（不可变）序列
• 元组再保留列表大多数功能的同时，去掉了一些灵活性以换取更高的处理性能 创建元组
• 列表的下标顺序从0开始，是连续的

创建元组的方法

• 圆括号法
• 指明类型法tuple（）

a=(1,2,3,4)
b=tuple(a)=

8字典

定义

• 标签收纳盒。给数据贴上标签，就可以通过具有特定含义的名字或者别的记号来获取数据
• 通过标签来索引数据，区别于列表或者元组通过连续的整数来索引
• 字典的容器中保存着一系列的key-value对
• 通过键值key来索引元素value

创建一个字典

花括号法和指明类型法

student={}
student=dict()

数据类型
字典中保存的各个标签-数据值
标签和数据值之间用冒号“：”连接
批量添加数据项

seq = ('Google', 'Runoob', 'Taobao')

dict = dict.fromkeys(seq)
print("新字典为 : %s" % str(dict))

dict = dict.fromkeys(seq, 10)#有初始值10
print("新字典为 : %s" % str(dict))

字典是可变类型，可以添加、删除、替换元素
字典中的元素value没有顺序，可以是任意类型，甚至也可以是字典
字典的键值key可以是任意不可变类型（数值/字符串/元组)

更新字典

合并字典：update方法

student={}#创造一个空的字典
student["name"]="Tom"
student["age"]="20"
student["gender"]='male'
print(student)
bar={"course":["数学","英语"]}
student.update(bar)
print(student)
#运行结果
{'name': 'Tom', 'age': '20', 'gender': 'male'}
{'name': 'Tom', 'age': '20', 'gender': 'male', 'course': ['数学', '英语']}

增长字典：关联操作，update操作：以key=value的形式批量添加数据项

“关联”操作

创造一个空的字典，然后和另外一个字典相等，即为和它的关联

student={}#创造一个空的字典
teacher={}
student["name"]="Tom"
student["age"]="20"
student["gender"]='male'
teacher=student
print(teacher)
#运行结果
#{'name': 'Tom', 'age': '20', 'gender': 'male'}

update操作

上面的update操作是直接增加了一个数据库，而这个是增加一个key-value的组合

student={}#创造一个空的字典
student.update(fridends=["Mike","Alice"])
print(student)
#运行结果
#{'fridends': ['Mike', 'Alice']}

缩减字典

del操作：删除指定标签的数据项
pop操作：删除指定标签的数据项并返回数据值
popitem操作：删除并且返回任意一个数据项

del操作

student={}#创造一个空的字典
student.update(fridends=["Mike","Alice"])
print(student)
del student["fridends"]
print(student)
#运行结果
{'fridends': ['Mike', 'Alice']}
{}

pop操作

返回的是删除的值，用pop可以将字典中的数据项逐个移走
A、默认移除最后一个元素

list = [1, 2, 3, 4, 5]
a = list.pop()#当括号内没有参数时，就默认删除最后一个元素
print (list, a)

B、移除list中的某一个元素：pop(元素序号)

list = [1, 2, 3, 4, 5]
a = list.pop(2)
print (list, a)
#输出结果
[1, 2, 4, 5] 3

其他具体情况参考https://www.cnblogs.com/volcao/p/8696306.html

popitem操作

删除并且返回任意一个数据项,括号内没有任何参数，在字典内删除任何一个删除

student={}
student["name"]='madongmei'
student["gender"]='women'
student['age']=20
print(student)
print(student.popitem())
print(student)
student.clear()
print(student)
#运行结果
{'name': 'madongmei', 'gender': 'women', 'age': 20}
('age', 20)
{'name': 'madongmei', 'gender': 'women'}
{}

clear操作

清空字典内的所有内容，移走所有的数据项
代码示例见popitem代码

字典大小

len函数

student={}
student["name"]='madongmei'
student["gender"]='women'
student['age']=20
print(len(student))
#运行结果
3

访问字典的数据项

标签索引

dict[key]#基本格式
student={"name":"Tom","age":20,"gender":"male"}
print(student["name"])
#输出结果
'Tom'

• 获取字典中指定标签的数据值
• 更新指定标签的数据项，即可以利用student[‘age’]=40的方式修改字典中的值

get

student={"name":"Tom","age":20,"gender":"male"}
print(student.get("name"）)
#输出结果
'Tom'

虽然和上一种方法形式上相似，但是不能作为变量使用，get出来的value就不能去实时更新它了，是一个只能看的状态

获取字典的标签、数据值和数据项

keys函数：返回字典中的所有标签
values函数：返回字典中的所有数据值
items函数，将每个数据项表示为二元元组，返回所有的数据项

student={}
student["name"]='madongmei'
student['age']=40
student['gender']='woman'
print(student.keys())
print(student.values())
print(student.items())
#输出结果
dict_keys(['name', 'age', 'gender'])
dict_values(['madongmei', 40, 'woman'])
dict_items([('name', 'madongmei'), ('age', 40), ('gender', 'woman')])

在字典中查找

in操作

判断字典中是否存在某个标签
代码示例见下一个部分

in操作和values函数的组合

判断字典中是都存在某个数据值

student={"name":"Tom","age":20,"gender":"male","courses":['math','computer']}
print('name' in student)
print('city' in student)
print(20 in student.values())#values和in的结合
#输出结果
True
False
True

9.集合

定义

• 标签的容器
• 如果字典是带着标签的盒子，通过标签来访问的话，那么集合就是集合就是一个标签袋。相当于字典中只留下标签，而把标签中的数据对象给删除了
• 在字典中标签key具有唯一性，那么集合就是不重复元素的无序组合
• 和数学中的集合概念相似

创造集合

创建集合：{}或者set()

• 可以用set（）从其他序列转换生成集合
• 集合会自动忽略重复的数据
• 集合中的标签是不可变的数据类型

更新集合

增长集合：add/update

• add：添加一个数据

a = set('abracadabra')
# b = set('alacazam')
print(a)
# print(b)
a.add(1.23)
print(a)
#输出结果
{'b', 'c', 'r', 'd', 'a'}
{1.23, 'b', 'c', 'r', 'd', 'a'}#无序

• update：批量添加数据

a = set('abracadabra')
print(a)
a.update('123')
print(a)
#运行结果
{'c', 'b', 'a', 'd', 'r'}
{'c', '2', 'b', 'a', 'd', 'r', '3', '1'}

缩减集合：ramove/discard，pop，clear

remove/discard：删除指定数据
discard和remove的功能一样，但是如果输入一个不存在的参数时，discard不会出错
pop：删除任意数据并返回值
clear

集合的大小：len

len

访问集合的元素：in、pop、迭代循环

• in：判断元素是否属于集合
• pop：删除数据元素的同时，返回它的值，取遍所有的元素后，集合成为一个空集，可以用copy操作先给集合制作一个替身
• 迭代循环 for a in aset，用for循环及其他形式，取遍集合中的值

集合运算

对称差就是将a-b和b-a并在一起

aset=set('abc')
print(aset)
print('a'in aset)
print(aset|set('bcd'))
print(aset&set(['b','c','d']))
print(aset-set(('b','c','d')))
print(aset^set('bcd'))
print(aset<=set('abcd'))
print(aset>set('abcd'))
#输出结果
{'b', 'c', 'a'}
True
{'b', 'c', 'a', 'd'}
{'b', 'c'}
{'a'}
{'d', 'a'}
True
False

生成新集合运算

关系判定

<=,=,>:子集（<=）/真子集(<)/超集(>=)/真超集(>)

交集

isdishoint：两个集合交集是否为空

什么时候用集合

• 快速去除重复的数据项
• 判断元素是否在一组数据中，如果这些数据的次序不重要，使用集合可以获得比列表更好的性能

10.数据类型的可变和不可变类型

数据收纳的灵活性

• 不可变类型 一旦创建就无法修改数据值的数据类型。如整数、浮点数、复数、字符串、逻辑值、元组

• 可变类型：可以随时改变的数据类型。如列表、字典、集合。灵活性强会花费一些计算或者存储的代价去维持这些强大的功能。

变量的引用特性

可变类型的变量操作需要注意，多个变量通过赋值引用同一个可变类型的对象时，通过其中任何一个变量改变了可变类型的对象，其他变量也随之改变，因为它们用的是同一个对象。

a=[1,2,3,4]
print(a)
b=a
print(b)
print(id(a))
print(id(b))#id是python内置函数，用来查看它所指向数据对象的地址的
a[0]='hello'
print(a)
print(b)
#输出结果
[1, 2, 3, 4]
[1, 2, 3, 4]
2668622248832#两个变量的存储地址相同！
2668622248832
['hello', 2, 3, 4]
['hello', 2, 3, 4]

11.建立复杂的数据结构

比较几种数据结构

1. 使用方括号[]创建的列表

2. 使用圆括号()创建的元组

3. 使用花括号创建的字典和集合

    每种类型中，都可以通过方括号对单个单元元素进行访问。
    对于列表和元组，方括号里是**整数的偏移量**
    对于字典，方括号里是**键**
    都是返回**元素的值**
   

将这些内置的数据结构自由的组合成更大、更加复杂的结构
创建自定义数据结构的过程中，唯一的限制来自于这些内置数据本身

建立大型数据结构：列表/元组

建立3个不同的列表

alist=[1,2,3]
blist=['HELLO','PYTHON']
clist=[True,False]

嵌套列表/元组

list_of_lists=[[1,2,3],['HELLO','PYTHON'],[True,False]]
tuple_of_lists=([1,2,3],['HELLO','PYTHON'],[True,False])

嵌套字典

dict_of_lists={'num':[1,2,3],'word':['HELLO','PYTHON'],'bool':[True,False]}

字典的元素可以是任意类型，甚至也可以是字典
字典的键值可以是任意不可变类型
例如：用元组作为坐标，索引坐标

alist=[[25,34,45],[True,'ab']]
alist[0][2]

bands={'Marxes':['Moe','Curly'],'KK':[True,'moon']}
bands['KK'][0]

poi={(100,100):'zhongguancun',(123,23):'Pizza'}
poi[(100,100)]

12.输入和输出

来料加工：input

input(prompt)
#prompt 为提示符

• input（）返回值是字符串。通过int()函数将字符串类型强制转换为整数类型

产品展示：print

打印各个变量的值输出。

print([object,...][,sep=' '][,end='\n'][,file=sys.stdout])

• sep：表示变量之间用什么字符串分隔开，缺省是空格
• end：表示以这个字符串结尾，缺省为换行
• file：指定了文本将要发送到的文件、标准流或者其他类似的文本的对象：默认是sys.stdout
• print函数默认将对象打印到stdout流，并且添加了一些自动的格式化（可以自定义分隔符和行末符）

格式化字符串

yname= input("please input your name")
print(yname)
print(1,23,'Hello')
print(1,23,'Hello',end=' ')
print(1,23,'Hello',sep=',')
print('%d %s'%(23,'Hello'))
print('%d'%(23,))
print('(%4d):K:%s'%(12,'Hello'))
print('(%04d):K:%s'%(13,'HELLO'))
#输出格式
please input your nameliu
liu
1 23 Hello
1 23 Hello 1,23,Hello
23 Hello
23
(  12):K:Hello
(0013):K:HELLO

5.变量和引用

给数据命名

命名语法

名字=数据

命名规则

• 字母和数字组合而成，下划线算作字母，字母区分大小写
• 不带特殊字符（如空格，标点和运算符等）
• 名字的第一个字符必须是字母，而不能是数字（在python语言的名字规则中，汉字算作是字母）

名字

• 名字像是一个标签，通过赋值来贴在某个数据的数值上
• 名字和数值的关联称为引用
• 关联数值后的名字，就拥有了数据的值和类型
• 一个数值可以和多个名字关联

变量

与数值关联的名字也称作变量，表示名字的值和类型可以随时发生变化。
变量的值类型可以随着引用不同的变量类型而发生变化
变量随时可以指向任何一个数据对象
python是一个动态的语言，名字和数值是一个引用的关系，而在C语言和C++中，变量的类型在产生时就已经定义好了

赋值

名字和数值关联的过程，称作赋值
“==”是对数值的相等性进行判断
“=”则是对计算等号右边式子的值，赋值给等号左边的变量

赋值语句

通过赋值号将变量和表达式左右相连的语句
赋值语句the_sum=0,实际上是创建了名为the_sum的变量，然后指向数据对象“0”

灵活多变的赋值语句

最基本的赋值语句形式

名字=数值

合并赋值

a=b=c=1

按顺序依次赋值

a,b,c=7,8,9

简写赋值语句

a+=1
a*=2
a/=3+4

6.计算和控制流

计算与流程

对现实世界处理和过程的抽象
各种类型的数据对象，可以通过运算组织成复杂的表达式

运算语句

1. 将表达式赋值给变量进行引用
2. 赋值语句用来实现处理和暂存

表达式计算

n=12*34

函数调用

p2=math.sqrt(2)

赋值

pfg=math.sqrt
pfg(2)

控制流语句

定义

控制流语句用来组织语句的描述过程

顺序

• 条件 if
• 循环 for while
• 定义语句：def，class
• 定义语句也用来组织语句，把一系列的运算语句集合起来起一个名字。描述了一个包含一系列处理过程的计算单元，主要为了源代码， 可以定义函数、类等代码对象
• 调用函数或者类，也可以得到数据对象，python里所有可以调用的事物统一成为callable 函数定义

1.控制流程

基本概念

• 在计算机运行过程中，”下一条语句“决定了计算机是能够自动调整、自动反复操作，还是只能像计算器那样以部接着一步计算
• 这种决定"下一条语句"的机制，在程序设计语言中称作"控制流程"

python语言中的控制流程

1. 顺序结构：按照语句队列前后顺序来确定写一条将要执行的语句
2. 条件分支结构：根据当前情况来选择下一条语句的位置
3. 循环结构：周而复始地执行一系列语句

几乎所有地程序设计语言都提供了着三种流程控制

计算机的"容器"：一个类比

简单类型与容器类型

• 简单类型和容器类型之间的关系，就像是玻璃珠与盒子、苹果与口袋
• 简单类型是实体堆型
• 容器类型是结构，将实体对象进行各种组织和编排

计算语句和结构语句

• 就像是简单类型和容器类型之间的关系
• 用顺序、条件分支和循环结构，来对各个赋值语句进行编排，最终成为解决问题的程序

2.控制流：条件分支语句（if）

基本要素

1. 预设的判断条件
2. 达成条件后执行的语句

扩展要素

1. 当条件不满足时执行的语句
2. 多条件时那个满足执行哪个条件

Python中条件分支的实现

• if和else都是“保留字”
• “逻辑表达式”使之所有运算的结果为逻辑类型（True或者False）的表达式
• “语句块”就是条件满足之后执行的一组语句
• 冒号表示语句的层次
• 语句块缩进
  各种类型中某些值会自动被转换为False 其他值则是True：
  None，0，0.0,’ ',(),[],{}.set()

使用多条if判断

使用else子句进行判定

使用elif语句进行判定

不再像else和if结合的语句一样需要缩进，时python设计的更为便捷美观的形式

a=12
if a>10:
	print("Great!")
elif a>6:
	print("Middle!")
else:
	print("Low!")
#输出结果
Great!

控制流：条件循环（while）

循环结构

让计算机执行冗长单调的重复任务

根据需要对一系列操作进行设定次数或者设定条件的重复，这样的控制流程，就称作循环结构

作用

• 能持续对大量数据进行处理
• 能在长时间内对一些位置的状况进行连续监测循环结构

循环结构的要素

基本要素

• 基本要素包括：循环前提和执行语句
• 在执行这组语句前，计算机会检查循环前提是否存在，只要存在，就会反复执行这一组语句，知道循环前提消失

循环前提

循环前提的类型

1. 从某个容器或者潜在的数据集中注意获取数据项，什么时候取不到数据项了，循环的前提就消失
2. 只要逻辑表达式计算结果为真，循环的前提就存在，什么时候逻辑表达式的计算结果为假，循环的前提就消失
   扩展要素
   当循环前提消失，停止执行这组语句的时候，执行一次另一组语句

条件循环

while循环语法

• 可以用break，continue，用法同C语言 else：条件不满足退出循环，则执行语句块`
• while、else：保留字
• 逻辑表达式：指所有运算的结果为逻辑类型的表达式
• 语句块：一组一句

while<逻辑表达式>
	<语句块>
	break #跳出循环
	continue #略过余下的循环语句
	<语句块>
else：#条件不满足退出循环，则执行
	<语句块>

else语句仅仅在不满足while条件时才会执行，在用break跳出时，不能运行else后面的语句

n=5
while n>0:
    n=n-1
    if n<2:
        continue
    print(n)
else:
    print('END!')
#运行结果
4
3
2
END!

嵌套

多重甚至多重的循环

for i in range(1,10000):
    n=i
    step=0
    while n!=1:
        if n%2==0:
            n=n//2
        else:
            n=n*3+1
        step+=1
    else:
        print(i,"Traped",step,"steps")
#答案太多 此处不罗列了

终端程序运行：ctrl+C
通过修改程序中range函数的参数，还可以验证其他范围的连续整数

控制流：迭代循环（for）

什么是迭代循环

迭代循环语句
python语言中的for语句实现了循环结构的第一种循环前提

for<循环变量> in<可迭代对象>
    <语句块1>
    break#跳出循环
    continue#略过余下循环语句
else:#迭代完毕，则执行
	<语句块2>

for循环语法

• for、in、和else都是“保留字”
• 可迭代对象表示从这个数据对象中可以逐个抽出数据项赋值给“循环变量”
• 可迭代对象有很对类型，如字符串、列表、元组、字典、集合等，也可以有后面提到的生成器和迭代器

#程序1
for n in range(5)
	print(n)
#输出结果 
0 
1
2
3
4
#程序2
alist=['a',123,True]
for v in alist
	print(v)
#输出结果
a
123
True
#程序3
adic={'name':'Tom','age':18,'gender':'Man'}
for k in adic:
    print(k,adic[k])
#运行结果
name Tom
age 18
gender Man
#程序4
adic={'name':'Tom','age':18,'gender':'Man'}
for k,v in adic.items():
    print(k,v)
#运行结果
name Tom
age 18
gender Man

range函数

range(<终点>)
返回一个从0开始到终点的数列
range(<起点>,<终点>)
从0叽歪的任何整数开始构建的数列
range(<起点>,<终点>,<步长>)
修改数列的补偿，通过将补偿设置为复数能够实现反向数列

range构建的数列，包含起点整数，而不包含终点整数
range类型对象

• 直接当作序列
• 转换为list或者tuple等容器类型
• 一般情况下我们使用的时候不需要转化，因为range中封装了一些很好的性质，用list或者tuple转换后反而会出错

print(list(range(10)))
print(range(10))
print(tuple(range(10)))
print(list((range(5,10))))
print(list(range(1,10,2)))
print(list(range(10,1,-2)))
#运行结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range(0, 10)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
[5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
[10, 8, 6, 4, 2]

嵌套循环中的跳出和继续

continue语句和break语句

• 都只能在循环内使用
• 都作用于离它们最近的一层循环
• break是跳出当前循环并且结束本层循环
• continue是掠过余下循环语句并接着下一次循环