零基础Python（一）

语法、变量

①python中的缩进十分重要，需要使用缩进来指示代码块.缩进不正确，idea会报错的：

加个tab缩进：

空格数取决于自己，但至少需要一个。（标准的就是加TAB缩进）
必须在同一代码中使用相同数量的空格，否则会报错。


②注释
注释以#开头，可以放在一行的末尾。
③变量
python没有声明变量的命令，首次为其赋值时，才会创建变量。
ex：

x = 10
y = "bili"

变量不需要使用任何特定类型声明，甚至可以在设置后更改其类型！！

x = 10 
x = "bili"

变量可以使用单引号或者双引号进行声明。命名规则和java一样。区分大小写。
python允许在一行中为多个变量赋值。

可以在一行中未多个变量分配相同的值。

对于数字，+字符可用作数学运算符。
但如果尝试字符串和数字，就会报错：

全局变量： 在函数外部创建的变量称为全局变量。
全局变量可以被函数内部和外部每个人使用。如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用。具有相同名称的全局变量将保留原样，并拥有原始值。
global关键字： 通常在函数内部创建变量时，该变量时局部变量，只能在该函数内使用。但如果要在函数内部创建全局变量，则可以使用global关键字。(可以在内部定义，但目前来看，并没有必要)

数据类型

可以使用type()函数获取任何对象的数据类型。

数字

Python中的数字有三种类型：
int/float/complex;复数用j作为虚部编写

x = 10 #int
y = 6.3 #float
z = 2j #complex 
v = 2+3j #complex

可以使用**int()/float()/complex()**方法从一种类型转化为另一种类型。
ex:

无法将复数转为其他数字类型！！

python中没有random()函数作为创建随机数。但是！有一个名为random的内置模块，可以生成随机数。(贴心)

指定变量类型
使用构造参数完成在python中的转换：
int() - 用整数字面量、浮点字面量构造整数（通过对数进行下舍入），或者用表示完整数字(不能是浮点型)的字符串字面量
float() - 用整数字面量、浮点字面量，或字符串字面量构造浮点数（提供表示浮点数或整数的字符串）
str() - 用各种数据类型构造字符串，包括字符串，整数字面量和浮点字面量
ex:

字符串

python 中的字符串可以用单括号和双括号,也可以用三个双引号或者三个单引号。
单引号和双引号作用相同：'hello’等同于"hello"
三单引号/三双引号可以保持字符串的格式，比如分行，空格等。

""" Hello!
     KuLv! """

字符串是数组跟很多流行的编程语言都一样，python的字符串是表示unicode字符的字节数组。
但是有一点不同，python没有字符数据类型，单个字符就是长度为1的字符串。
方括号可以用于访问字符串的元素。

裁切
可以使用裁切预发返回一定范围的字符。需要指定开始索引和结束索引，以冒号分割，以返回字符串的一部分。

开始索引是闭区间，结束索引是开区间，这点要注意。
字符串长度
使用len()函数

其他字符串内置方法：

• strip()：去除开头和结尾的空白字符
• lower()：返回小写的字符串
• upper(): 返回大写的字符串
• replace(): 用另一段字符串来替换字符串
• split(): 通过分隔符拆分字符串
• so on…
  ex:

检查字符串
如果需要检查字符串是否存在特定短语或字符，可以用in 或者 not in 关键字。
字符串级联
如果要串联或者组合两个字符串，可以使用 + 运算符。
字符串格式
我们不能通过+运算符来组合字符串和数字！但是可以通过format()方法来组合。
format()方法接受传递的参数，格式化参数后将他们放在占位符{}所在的字符串中，该方法接受不限数量的参数，并放在各自的占位符中。

接上面的其他字符串方法：



一些操作的说明：

1.字符串分割：
str=‘where is my dream’
temp=str[:8]
====>temp=‘where is’

可见这个分片连字符串也可以分割的。

2.字符串的插入跟tuple基本一致：

str=str[:8]+'heart'+str[8:] =》str='where isheart my dream'

3.capitalize()----->把字符串的第一个字符改为大写
casefold()------->把整个字符串的所有字符改为小写
center(width)—>将字符串居中，并使用空格填充至长度width的新字符串
count(sub[,start[,end]])—>返回sub在字符串里边出现的次数，start和end参数表示范围，可选
encode(encode=‘utf-8’,errors=‘strict’)---->以encoding指定的编码格式对字符串进行编码
endswith(sub[,start[,end]])---->检查字符串是否以sub字符串结尾，如果是返回True，否则返回False，start和end参数表示范围，可选
expandtabs([tabsize=8])---->把字符串中的tab（\t）符号转换为空格，如不指定参数，默认的空格数量是tabsize=8个，这个8是包含前面字符的。
find(sub[,start[,end]])----->检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数表示范围，可选
index(sub[,start[,end]])---->跟find方法一样，不过如果sub不在string中会产生一个异常
isalnum()---->如果字符串至少有一个字符并且所有自负都是字母或数字，则返回T入额，否则返回false
isalpha()---->如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False
isdigit()------>如果字符串值只包含数字则返回True，否则返回False
islower()----->如果字符串至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False
isnumberic()----->如果字符串只包含数字字符，则返回True，否则返回False
isspace()----->如果字符串只包含空格，则返回True，否则返回False
istitle()------->如果字符串是标题化(所有的单词都是以大写开始，其余字母都是小写)则返回True，否则返回False
isupper()----->如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回True，否则返回False
join(sub)----->以字符串作为分割符，插入到sub中所有的字符之间
ljust(width)---->和上面的center对应，返回一个左对齐的字符串，并使用空格填充至长度为width的新字符串
lower()----->转化字符串中所有大写字符为小写
lstrip()------>去掉字符串左边的所有空格
partition(sub)---->找到字符串sub，把字符串分成一个三元组，如果字符串中不包括sub则返回(‘原字符串’,‘’,‘’)
replace(old,new[,count])—>把字符串中的old字符串替换为new子字符串，如果count指定，则替换不超过count次
rfind(sub[,start[,end]]----->类似于find(),不过是从右边查找
rindex(sub[,start[,end]])---->类似于index()方法，不过是从右边开始查找
rpartition(sub)…
rstrip()-------->删除字符串末尾的空格
split(sep=None,maxsplit=-1)------>不带参数默认是以空格作为分隔符切片字符串，如果maxsplit参数有设置，则仅分割maxsplit个字符串，返回切片后的子字符串拼接的列表
splitlines([keepends])…
startswith(prefix[,start[,end]])----->检查字符串是否以prefix开头，是则返回True，否则返回False，start和end参数可以指定范围检查，可选。
strip([chars])----->删除字符串前边和后边所有的空格，cahrs参数可以定制删除的字符，可选。
swapcase()-------->翻转字符串中的大小写
title()------>返回标题化的字符串
translate(table)------>根据table的规则（可以由str.maketrans(‘a’,‘b’)定制）转换字符中的字符
upper()------>转换字符串中的所有小写字符为大写
zfill(width)---->返回长度为width的字符串，原字符串右对齐，前边用0填充

---

字符串格式化：
格式化输出嘛，你懂得，无非套个模板，输入自己的变量，对应java中的String.format(),不过貌似python的格式化输出更强一些，python的字符串格式化有三种方法：
1.位置映射：
“{}:{}”.format(‘i love you’,‘forever’)
ex:

 'Who i {0}is {1}'.format('love','you')
 ----->'Who i loveis you'

2.关键字映射：
“{server}{0}:{1}”.format(‘this is’,‘china’,server=‘mobile’)
ex:

 'The {param} you {0} is {1}'.format('leave','2018',param='time')
 -------->'The time you leave is 2018'

这里需要注意一点，在format函数中，位置参数必须在关键字参数之前，否则会报错的！
这里提一下转义字符：
\\–>打印出来就是一个反斜杠
\t–>打印出来就会看到前面空了一个TAB的位置
必须调用print()函数才会有效果。
这里如果我们想打印出来大括号，则可以在外面再套一层大括号，ex：

 '{{0}}'.format('随便填')
 ----->'{0}'

3.格式符
格式化为真实值预留位置，并控制显示的格式。格式符可以包含一个类型码，用以控制显示的类型，类型码如下：
%c 单个字符
%s 字符串（采用str()的显示）
%r 字符串（采用repr()的显示）
%b 二进制整数
%d 十进制整数
%o 八进制整数
%x 十六进制整数
%e 指数（基底写为e）
%E 指数（基底写为E）
%f 浮点数
%F 浮点数，与上面的相同
%g 指数或浮点数
%G 指数或浮点数
%% 字符‘%’
字符串通过tuple，也就是元组传入实际的值
ex：

'%d +%d=%d' % (1,1,3)
'%o' % 10---->'12'
'%e' % 27.658--->'2.765800e+01'
'%d%%' % 24---->'24%'
'%5.1f' % 251.1234--->'251.1'

---

字符串的一些相关操作：
1.在字符串中分行，输入\n即可：

>>> print('time\n is\n possiable')
time
 is
 possiable
>>> 

2.如果想去除字符串右边的空格符，可以用rstrip()方法：

>>> a='python  '
>>> print(a)
python  
>>> b='python     '
>>> a==b
False
>>> a.rstrip()==b.rstrip()
True

同理，如果想去掉左边的可以用lstrip(),两边都去掉的话用strip()

布尔值

python 中的布尔值是True/False，首字母大写。
评估值和变量:
bool()函数可以评估任何值，并返回True或False.
大多数值都为True
评估规则：

如果有某种内容，则几乎所有值都将评估为 True。
除空字符串外，任何字符串均为 True。
除 0 外，任何数字均为 True。
除空列表外，任何列表、元组、集合和字典均为 True。

ex:

运算符

• 算术运算符

• 赋值运算符

• 比较运算符

• 逻辑运算符

• 身份运算符

• 成员运算符

• 位运算符
  常规的就不说了，说几个java里没有的：
  ①算术运算符：

• ** 幂运算 x**y

• // 地板除 x//y
  
  可以看到，这里的地板除就是取整除，跟java里的除一个性质。只不过python的除是取整除,而是整+余.
  赋值运算符

• **= 例子：x**=3 等同于 x = x**3

• &= x&=3 x = x&3

• |= x|=3 x = x|3

• ^= x^= 3 x = x ^3

• >>= x>>=3 x= x>>3

• <<= x<<=3 x= x<<3

逻辑运算符

• and 如果两个语句都为真，则返回True ,ex: x > 3 and x < 10

• or 如果其中一个语句为真，则返回True ,ex: x>3 or x < 4

• not 反转结果，如果结果为True,则返回false
  实际上分别对应java中的 && || ！
  身份运算符

• is 如果两个变量时同一个对象，则返回True. x is y

• is not 如果两个对象不是同一个对象，则返回True. x is not y
  成员运算符
  用于测试序列是否在对象中出现。

• in

• not in

位运算符【需要注意，虽然java业务开发中不常用，但是python的脚本里这些绝对是常客】

• 与() : 两个操作数中位都为1，结果为1，否则为0.
• 或(|) ：两个数对应位只要有一个为1，结果就为1，否则为0.
• 异或(^) ：两个数对应位相同则为0，不同则结果为1.
• 非(~) : 如果位为1，结果是1，如果位是1，结果是0.【这是个单目运算符】
• 左移(<<) : 位向左移动对应个数
• 右移(>>) : 位向右移动对应个数

集合

python中有四种集合数据类型：

• 列表(List)是一种有序和可更改的集合。允许重复的成员
• 元组(Tuple)是一种有序且不可更改的集合。允许重复的成员
• 集合(Set)是一个无序和无索引的集合。没有重复的成员
• 词典(Dictionary)是一个无序，可变和有索引的集合。没有重复的成员
  **python 没有数组！！**所以其工作只能交给list来做了。

列表(list)

列表是用中括号的[]
列表除了可以存放单一类型的数据，还可以存储不同类型的数据。

一些基础操作：
访问项目：
可以通过索引来访问列表项
负的索引
负索引表示从末尾开始，-1表示最后一个项目，-2表示倒数第二个项目，以此类推。（这个操作还蛮骚的）
索引范围
可以通过指定范围的起点和终点来指定索引范围。
负的索引范围
如果需要从列表末尾开始搜索，可以指定负索引

索引区间是前闭后开的，所以mixList[-4:-1]中没有返回’continue’
遍历列表
可以使用for循环遍历列表项

图上只是遍历的一种而已，在看循环的时候姿势更多。
检查列表中是否存在指定的项
用in关键字。
列表长度
又是用熟悉的len()。【len():劳资可不是只能测字符串嘞！】

列表其他操作

1.添加元素
①append()
一次只能添加一个元素，加多个会报错的。这个是在列表末尾添加元素。
ex:member.append('虫师')
如果想一次加多个元素，可以使用：
②extend()
member.extend([''没有黄段子的无聊世界,'命运石之门'])，实际上
extend()也只能接收一个元素，这个元素是个列表，列表里可以存放多个元素。
③insert()
append()、extend()都是把元素添加到列表末尾。而insert()则不同：
insert(int pos,object item), 第一个是插入的位置，第二个是插入的元素
ex:
member.insert(1,['Ok','No'])

2.删除元素

member[pos]取数据元素也是这种操作，嗯，跟java，c一样。
①remove()
remove(元素值)，比如上面的remove(‘天行九歌’)，这个只能删除一个，多个的话，需要遍历删除了。
②del(是一个语句，不是方法，所以不用括号)，ex：
del member[1] 删除第二个元素
del member 删除整个列表
③pop()【列表毕竟是个栈嘛，有这个也不为怪】
从列表中取出最后一个元素，返回出来，这样列表中也就没了。
member.pop()
④clear() 清空列表
member.clear()

4.列表分片(Slice)
利用分片，可以一次性取多个元素。分片也很简单，记住，前闭后开，如下：
member[1:3] 前闭后开，会取出pos为1,2的两个元素
member[ :3] 会取出pos为0,1，2的三个元素
member[1: ] 为取出pos为1以及之后的元素
member[] 会取出真个列表的元素
可以通过分片赋值给其他列表，然后进行相关的操作。注意，别越界了！！
正如之前负数可以指代最后几个元素，切片也可以使用负数分片用来从列表后面取数据。
比如，取列表的最后三个元素：

b=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> c=b[-3:]
>>> c
[15, 17, 19]

5.比较操作符、逻辑操作符、连接操作符、重复操作符、成员关系操作符

①list可以比较大小 ex：
list[123]>list[456] False
list[123,456]>list[234,324] False,
如果有多个元素，就会只比较第一个元素；
如果是字符串，那么就根据ASCII码来比较
②list也可以相加 ex：
list1=[123]
list2=[456]
list3=list1+list2
list3-----》[123,456]
Tip：尽量不要这么加，用append、extend方法才是规范用法；list只能加list，不能加其他类型的变量。
③list可以进行乘法操作

list1*3  =》[123,123,123]

④in、not in操作符
用来判断元素在不在列表中；

456 in list1  =》False

123 not in list1 =》False

Tips：in 、not in只能判断一层，内嵌的list中的元素是察觉不到的，ex：

list4 = [123,['天马行空','万里奔腾'],456]
'天马行空' in list4  =》False
'天马行空' in list4[1] =》True
list[1][1] =》万里奔腾

⑤dir(list) =》查看list的BIF
列一下吧：
append、clear、copy、count、extend、index、insert、
pop、remove、reverse、sort
ex：
list4.count(123) =》会返回list4中123出现的次数
list4.index(123) =》会返回list4中123的索引值，第一次出现的索引值
list4.index(123,3,7) =》返回list4中索引3到7之间123的索引值
list4.reverse() =》成员顺序反转【前后颠倒】
list4.sort() =》成员排序，从小到大

>>> ss=[1,'abc','zzg',2]
>>> ss.sort()
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    ss.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

如果列表中有不同类型的item，那么比较会报错的，要同等类型比较。
而且用sort()函数进行排序后，列表的顺序就不会再回到原来的排序了。如果想保留原来的排序，只是临时拍一下序，就用sorted()函数就可以。

如果想从大到小：
list4.sort(reverse=True),即可反转
这里需要注意的是，切片和直接赋值的区别：
list2=list1[:]
list3=list1,
list2和list3赋值之后虽然都一样，但是如果对list1进行排序
那么list3排序也会跟着改变。这就很尴尬了。所以赋值最好用切片，
保持原则才是最好的。
Tips:能用BIF解决的事情，就不要用算数运算符操作。很容易导致问题的出现。
⑥避免索引错误
有时候为了防止列表越界报错，比如只有三个元素，你们下标为4的元素，肯定数组越界，python中，为了取最后一个元素，可以采用listName[-1]这种操作，用-1指代最后一位元素。-2是倒数第二个，以此类推。【这种操作比java好的多，可以用这个】
⑦生成数值列表可以使用range()函数：

>>> for i in range(1,10):
print(i)

1
2
3
4
5
6
7
8
9

也可以将之转换为列表：list(range(1,10))
⑧复制列表
通过list2 = list1来复制的，list1的改动也会应道list2，因为list2并不是一个新的列表，只是list1的一个引用。

有一些方法可以复制列表：
copy()/list()

mixList = [1, 'Rye', True, "Ok", "now", "we", "can", "continue"]
mixList2 = mixList.copy()
mixList.clear()
mixList3 = list(mixList2)

for item in mixList2:
    print(item)
输出:
1
Rye
True
Ok
now
we
can
continue

可以看出mixList已经被清空了，mixList2依旧有输出，说明确实是一个新的列表。
最后贴一张列表中的所有操作：

元组

元组和列表类似，很多列表的操作，元组也可以，像分片等，但也有区别：
1.元组是用圆括号
2.元组是不能被修改！【但有方法在一个元组上修改得到一个新的元组，看似是修改，实则不然，跟str一样】

基本操作

访问元组项目
可以通过索引来访问元组元素。
负索引
操作及含义同list。
索引范围
操作及含义同list。
负索引范围
同上。
更改元组值
创建元组后，将无法更改其值。元组是不可变的。

>>> d=('zzg','SprrowZ','RyeCatcher')
>>> d[-1:]
('RyeCatcher',)
>>> d[0]='xg'
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    d[0]='xg'
TypeError: 'tuple' object does not support item assignment

如果想直接修改，只会收到报错信息~
但是也有解决方法，可以将元组转化为列表，更改列表，然后将列表转换为元组。
【之所以需要提供这种方案，可能是因为某些场景下我们需要一个没有重复元素的可新增删除的list】

还有另外一种思路：
新增：把元素分割成两部分，中间加上新增的元组即可：

temp=temp[:2]+('何处是鬼畜',)+temp[2:]

其他一些需要注意的点：
temp=(1) =》 创建的是int，如果想创建只有一个元素的元组：
temp=(1,) =》加一个逗号，这个逗号很关键的，空元组直接用小括号即可
8*(8,)---->(8,8,8,8,8,8,8,8)`

然后其他的操作就基本跟list类似了。

---

集合

集合是无序和无索引的集合，没有重复元素。用花括号编写。（这个集合跟java的集合不是一个概念）
集合是无序的，所以无法确定集合中的显示顺序，也无法通过下标来获取集合中的元素。

访问集合
所以没有顺序，但是仍然可以用foreach来遍历集合的元素。
添加元素
集合一旦创建，那其中的元素就无法改变，因为根本拿不到你想操作的元素，但是可以新增元素。有多种方式添加：
①添加一个元素，使用add()方法
②添加多个元素，使用update()方法

注意这个update方法，添加两个字符串的时候通过列表包装一下。因为update是将字符串拆分成字符追加的！如果不封装成列表、集合或者元组，就会插入多个单字符的字符串！

删除元素
1.可以通过remove()或discard()方法来删除元素；
2.pop()可以删除最后一个元素，因为集合无序，所以pop指不定删除哪个，返回值就是其删除的元素。
3.clear()方法可以清空集合。
4. del 彻底删除集合。

合并两个集合
可以使用union()方法返回包含两个集合中所有项目的新集合，
也可以使用update()方法将一个集合中的所有项目插入另一个集合中。
这两个函数都将排除任何重复项，因为集合没有重复元素。
①union()方法返回一个新集合，其中包含两个集合中的所有项目。
②update()方法将set2中的项目插入set1中。

Set的其他方法：

字典

字典是一个无序、可变和有索引的集合。字典也是用花括号编写，与集合不同的是字典拥有键和值。

创建字典：

字典基本操作

访问项目
可以通过键来访问元素或者get()方法。
mixDict[1] mixDict.get("model")

更改值
可以通过键名来更改特定项的值。
遍历字典
可以使用for循环来遍历字典。

mixDict = {
    "brand": "Bili",
    "model": 121,
    1: 3
}
# print(mixDict)
# print(mixDict[1])
# print(mixDict.get("brand"))
# 打印所有键名
for item in mixDict:
    print(item)
# 打印所有值
for item in mixDict:
    print(mixDict[item])
# 直接遍历值
for item in mixDict.values():
    print(item)
# 通过items()函数遍历值和键
for key,value in mixDict.items():
    print(key,value)

所以for遍历既可以遍历字典中的所有值，也可以遍历所有的键，还可以同时遍历键和值。
检查键是否存在
要确定字典中是否存在指定的键，还是用in关键字。

添加元素
通过使用新的索引值并为其赋值，就可以将元素添加到字典中去。

mixDict["hello"] = "KuGou!"
print(mixDict)

删除元素
有多种删除的方法：
① pop()方法删除具有指定键名的元素。

mixDict.pop("hello")

②popitem()方法删除最后插入的项目（在3.7之前的版本中，删除随机项目）

mixDict.popitem()

③del 关键字删除具有指定键名的元素，也可以完全删除字典

del mixDict["hello"]
del mixDict

④clear()关键字清空字典，内容清空了， 变量还在呢。

复制字典
不能通过dict2 = dict1来复制字典，原因跟list复制一样，假复制，只有持有原元素的引用而已。有效的方法：
①copy() 方法来复制字典
②dict() 方法来复制字典

嵌套字典
字典也可以包含许多字典，这被称为嵌套字典。
ex:

# 嵌套字典
mixDictFinal = {
    "dict1": {
        "a": "Alpha",
        "b": "Beta"
    },
    "dict2": {
        "c": "carry",
        "d": "destroy"
    },
    "dict3": {
        "f": "fight!",
        "e": "ele"
    }
}

字典的其他方法：

序列

序列是一种统一的说法，序列包含列表(list)、元组(tuple)、字符串(str)，没有集合
列表、元组和字符串的共同点：
①都可以通过索引得到每一个元素
②默认索引值总是从0开始
③可以通过分片的方法得到一个范围内的元素的集合
④有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）

list():把一个可迭代对象转换为列表。【可以不带参，也可以带一个迭代器的参数】
tuple([iterable]):把一个可迭代对象转换为元组。
迭代：所谓迭代就是重复反馈过程的活动。
ex：

b='Expectation is the root of all heartache.'
b=list(b)
b---->
['E', 'x', 'p', 'e', 'c', 't', 'a', 't', 'i', 'o', 'n', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 'r', 'o', 'o', 't', ' ', 'o', 'f', ' ', 'a', 'l', 'l', ' ', 'h', 'e', 'a', 'r', 't', 'a', 'c', 'h', 'e', '.']

c=(1,1,2,3,4,5,5,5)
c=list(c)
c--------->[1, 1, 2, 3, 4, 5, 5, 5]

in关键字
可以通过in来判断元素是否在序列中，当然序列包括列表、元组和字符串，in是适用于这三者：

>>> b=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> d=('zzg','SprrowZ','RyeCatcher')
>>> cc='dnf'


>>> 'zzg'in d
True
>>> cc='dnf'
>>> 'd'in cc
True
>>> 1 in b
True

如果是不包含，用not in用法一样。
几个函数：
【需要注意一点，用底下几个函数的时候，序列中不要char和int混用，会报错】
1.len(),取list的长度，里面传入的参数必须得是定义过的，不然会报错
2.max(),返回序列或者参数集合中的最大值，因为是序列，所以里面传str、tuple或者list都可以
4.min(),如上，取最小值
5.sum(),求和，要求同上
6.sorted(),序列排序，与list.sort()效果是一样的，默认从小到大
7.reversed(),返回迭代器列表，可以在外面包裹一层list()查看
8.enumerate(),返回带有index的元素，很骚
9.zip(),zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组,返回的是一个对象。如需展示列表，需手动 list() 转换。
ex：

    max(1,2,3,4,5)--->5
max(b)[上面的列表]---->'x'[根据ASCII码比较大小]
    max((1,2,3))------->3

如果是：

    min((1,2,3,4,5,'a'))

就会报错，int不能跟ASCII码直接比较。

sorted()、reversed()

a=[23,34,54,64,234,325,234]
sorted(a)
----》[23, 34, 54, 64, 234, 234, 325]
 reversed(a)
 -----》<list_reverseiterator object at 0x00000136633635F8>[迭代器对象]
 list(reversed(a))
 ------》[234, 325, 234, 64, 54, 34, 23]********貌似是个bug？待查+1

enmurate()

list(enumerate(a))
--->[(0, 23), (1, 34), (2, 54), (3, 64), (4, 234), (5, 325), (6, 234)]

zip()

a=[1,2,3,4,5,6,7,8]
b=[4,5,6,7]
list(zip(a,b))
------>[(1, 4), (2, 5), (3, 6), (4, 7)]

条件语句、 循环语句

If … Else

以下几点需要注意：

①python中有个关键字： elif 相当于 else if

②如果if中只有一条语句要执行，则可以将if语句放在同一行。

③判断条件和其他语言一样，常常会需要逻辑运算符：and or (&& || )

④判断亦可以嵌套使用，不过需要注意嵌套。

⑤if语句不能为空，如果真的没有内容可以执行，则用 pass关键字过滤掉

demo:

a = 1
b = 2

if a > b:
    print("a is greater than b")
elif a < b:
    print("b is greater tha a")
else:
    print(" a is equals b")

c = 3
if c < 5 and c > 0: print("{} is lower than 5,but greater than 0".format(c))

d = 6
if d < 7:
    if d > 0:
        print("{} is grater than 0 ,but lower than 7".format(d))
e = 7

if e == 7:
    pass

while循环

python中有两个原始的循环命令：while 和 for
可以使用break，continue；含义和java中一样。
不同的是，在while中可以使用else，当条件不再成立时去执行这个语句

for循环

for 循环可以用来迭代序列（列表、元组、字典、集合和字符串）
同样可以使用break continue方法
range()函数
如需循环一组代码指定的菜蔬，可以使用range()函数

for x in range(10):
  print(x)

注意值不是0~10，而是0到9.
else
for循环中的else关键字指定循环结束时要执行的代码块！

同样可以循环嵌套以及使用pass关键字。

其他：

先贴一些入门的代码：

import random
secret=random.randint(1,10)
print("**************恕瑞玛，你们的皇帝回来啦！****************")
temp=input("Hei,guy,Guess what number is my favorite...:")
guess = int(temp)
while guess != secret:
    temp=input("You guess wrong...Try again!:")
    guess=int(temp)
    if guess==secret:
        print("You guess right")
        print("But No Ruan Yong")
    else:
        if guess > secret:
            print("That's big!")
        else :
            print("That's small!")
print("Good Game")   

print("*************Demo***********")
temp=input("Please input the grade to class:")
grade=int(temp)
if grade > 90:
    print("Your grade is A...")
else :
    if grade >= 80 and grade < 90:
        print("Your grade is B...")
    else :
        if grade >= 60 and grade < 80:
            print("Your grade is C...")
        else :
            if grade < 60 :
                print("You should hava some B number in your heart...")
print("Game Over...")    

print("************3-2DemoEx*********")
temp=input("Please input you number:")
grade=int(temp)
if grade > 90:
    print("Your grade is A...")
elif grade >= 80 and grade < 90:
    print("Your grade is B...")
elif grade >= 60 and grade < 80:
    print("Your grade is C...:")
else :
    print("B number ,You know")      

这里需要针对上面代码进行一些说明：
1.python3的输出语句为：print(“内容…”)
2.python没有变量类型这一说，诸如java的String、int、boolean等等。
3.input()函数，就是等待用户输入，括号内是输入前的提示语句。
4.python有两个初学者必须知道的函数，分别为dir()和help(),通过这两个方法，我们可以查看概念相关的内置函数，也就是BIF；
dir()函数获得对象中可用属性的列表
help()函数帮助我们了解模块、类型、对象、方法、属性的详细信息
此外，
1.break、continue这俩Python也有；
2. * *、//,第一个是幂运算，比如2**3==8，第二个是地板除，所得除数定为整数。
3. python中，可以用字符串*整数，相当于复制了N份。ex：

>>> str1='hello'
>>> str2=str1*3
>>> str2
'hellohellohello'

4. 上面后面两段代码是为了了解elif这个关键字
   可以包含任意个elif语句。if-elif-else结构只会执行一个代码块，如果想运行多个代码块，可以使用一系列独立的if语句。

5. python中可以用import builtins (或直接使用__builtins__)查看内置函数，内置函数中，以字母形式的都可以用help(函数名)，来查看具体信息。

6. python的foreach语句：
   for 元素（随便起个名）in (字符串、列表什么的)
   print(元素)
   ex: for each in ‘Crazy’
   print(each)
   7.python的灵魂在于TAB键，相当于JAVA中的大括号了。

7. python三目运算符：
   　条件为真时的结果 if 判段的条件 else 条件为假时的结果