有Java基础快速入门Python

学习准备

因为之前系统学习过Java语言，所以这次学习Python想脱离完整视频教学，通过以前总结的经验来快速入门Python。打算边学习语法基础，边编写demo，最后实现完整的项目来实现python入门。语言只是实现目的的工具，工具就是用来使用的，只有不断的运行测试才能发现自己的不足，Make it run, make it right, make it fast。

语法基础

找到了两个路线来进行学习，第一个是官方tutorial，第二个为codecademy编程学院，当然只是路线，有些内容不具体或者不好理解的地方还要配合菜鸟教程等学习论坛来进行学习，这里我使用第一种官方tutorial进行学习。接下来开始正式学习。

一，了解python

Python 是一种解释型语言，不需要编译和链接，可以节省大量开发时间。Python 程序简洁、易读，通常比实现同种功能的 C、C++、Java 代码短很多，原因如下：

1. 高级数据类型允许在单一语句中表述复杂操作；
2. 使用缩进，而不是括号实现代码块分组；
3. 无需预声明变量或参数。
   Python 虽然简单易用，但它可是真正的编程语言，提供了大量的数据结构，也支持开发大型程序，远超 shell 脚本或批处理文件；Python 提供的错误检查比 C 还多；作为一种“非常高级的语言”，它内置了灵活的数组与字典等高级数据类型。正因为配备了更通用的数据类型，Python 比 Awk，甚至 Perl 能解决更多问题，而且，很多时候，Python 比这些语言更简单。
   语言的命名源自 BBC 的 “Monty Python 飞行马戏团”，与爬行动物无关（Python 原义为“蟒蛇”）。

二，Python解释器

关于安装python解释器的安装以及调用，网上教程很多，而且没有什么难度，所以这里略过。如果不想在电脑上安装python仅仅进行demo测试的话可以使用python123在线编译器进行编译学习。我这里装好了python，学习编译语言第一步，打开自带编译器IDLE，对新世界打个招呼。

三，标识

与Java一样，标识符可以使用下划线，大小写字母以及数字，且第一个字符不能是数字，且不能使用Python中的保留字。与Java不同的在于Python可以使用汉字来作为标识符。关于标识符命名的规范性都与Java相差无几。

四，数据类型

Python3 中有六个标准的数据类型：
1.Number（数字）
2.String（字符串）
3.List（列表）
4.Tuple（元组）
5.Set（集合）
6.Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

五，运算符

Python语言支持以下类型的运算符:

1.算术运算符

运算符	描述
+	两个数相加，或是字符串连接
-	两个数相减
*	两个数相乘，或是返回一个重复若干次的字符串
/	两个数相除，结果为浮点数（小数）
//	两个数相除，结果为向下取整的整数
%	取模，返回两个数相除的余数
**	幂运算，返回乘方结果

2.比较运算符

运算符	描述
==	比较两个对象是否相等
!=	比较两个对象是否不相等
>	大小比较，例如 x>y 将比较 x 和 y 的大小，如 x 比 y 大，返回 True，否则返回 False
<	大小比较，例如 x<y 将比较 x 和 y 的大小，如 x 比 y 小，返回T rue，否则返回 False
>=	大小比较，例如 x>=y 将比较 x 和 y 的大小，如 x 大于等于 y，返回 True，否则返回 False
<=	大小比较，例如 x<=y 将比较 x 和 y 的大小，如 x 小于等于 y，返回 True，否则返回 False

3.赋值运算符

Python可以同时给多个变量进行赋值，比如

a,b = 1,2

就实现了同时给变量a和b同时赋值，通过后续的学习了解到对于列表和元组也可以通过这种方式进行赋值，比如

(a,b,b) = ["aa","bb","cc"]
(a,b,c) = ("aa","bb","cc")

运算符	描述
=	简单的赋值运算符，将运算结果赋值给变量
+=	自增，加法赋值运算符，例如 a+=b 等效于 a=a+b
-=	自减，减法赋值运算符，例如 a-=b 等效于 a=a-b
*=	自乘，乘法赋值运算符，例如 a*=b 等效于 a=a*b
/=	自除，除法赋值运算符，例如 a/=b 等效于 a=a/b
%=	取模赋值运算符，例如 a%=b 等效于 a=a%b
**=	幂运算赋值运算符，例如 a**=b等效于 a=a**b
//=	取整除赋值运算符，例如 a//=b 等效于 a=a//b

4.逻辑运算符

运算符	描述
and	布尔“与”运算符，返回两个变量“与”运算的结果
or	布尔“或”运算符，返回两个变量“或”运算的结果
not	布尔“非”运算符，返回对变量“非”运算的结果

5.位运算符

运算符	描述
&	按位“与”运算符：参与运算的两个值，如果两个相应位都为 1，则结果为 1，否则为 0
|	按位“或”运算符：只要对应的两个二进制位有一个为 1 时，结果就为 1
^	按位“异或”运算符：当两对应的二进制位相异时，结果为 1
~	按位“取反”运算符：对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1
<<	“左移动”运算符：运算数的各二进制位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃， 低位补 0
>>	“右移动”运算符：运算数的各二进制位全部右移若干位，由“>>”右边的数指定移动的位数

6.成员运算符

运算符	描述
in	如果在指定的序列中找到值时返回 True,否则返回 False
not in	如果在指定的序列中没有找到值时返回 True,否则返回 False

7.身份运算符

运算符	描述
is	判断两个标识符是否引用自同一个对象，若引用的是同一个对象则返回 True，否则返回 False
is not	判断两个标识符是不是引用自不同对象，若引用的不是同一个对象则返回 True，否则返回 False

测试：

8.运算符优先级

运算符	描述
**	幂 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

六，控制语句

所有控制语句部分和Java的区别：
1，判断语句不使用括号分隔
2，半段语句结束要加：
3，不使用大括号而使用缩进来表示代码块

条件语句

if…else…与Java区别：else if直接写成elif

循环语句

for循环，与Java区别：python中for语句后可以跟else语句，即for语句如果正常循环结束（没有通过break打断循环）则执行else语句内的内容。
例：

for letter in 'Python':     # 第一个实例
   print("当前字母: %s" % letter)
 
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print ('当前水果: %s'% fruit)
else:
	print("水果循环正常结束")
print ("Good bye!")

输出结果

while循环

count=0
while(count<8):
   print ("THe count is", count)
   count+=1

print ("bye")

输出结果

嵌套循环，和Java没有什么区别

循环控制语句和java没有差别

控制语句	描述
break 语句	在语句块执行过程中终止循环，并且跳出整个循环
continue 语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句	pass是空语句，是为了保持程序结构的完整性。

break示例：

for letter in 'Python':     # 第一个实例
   if letter == 'h':
      break
   print ('当前字母 :', letter)
  
var = 10                    # 第二个实例
while var > 0:              
   print ('当前变量值 :', var)
   var = var -1
   if var == 5:   # 当变量 var 等于 5 时退出循环
      break
 
print ("Good bye!")

结果：在执行到python的h时直接跳出循环，执行到5的时候直接跳出循环。

continue示例：

for letter in 'Python':     # 第一个实例
   if letter == 'h':
      continue
   print ('当前字母 :', letter)
 
var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:
      continue
   print ('当前变量值 :', var)
print ("Good bye!")

结果：跳过python中的h，9到0的5

七，输入与输出

输入

Python 提供了 input() 内置函数从标准输入读入一行文本
如果要输入数字，字符串等特定格式，则在输入前加上输入格式，例如：

num=int(input())

表示只能输入数字，如果输入字符则会报错。

输出

Python有两种输出值的方式，表达式和print()函数。第三种方式则是文件的write()方法，标准输出文件可以用 sys.stdout 引用。如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。例如：

s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob'
>>> repr(s)
"'Hello, Runoob'"

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

name="mutianao"
print ("My name is %s"%(name))

输出格式和c++相似，使用%操作符进行输出
%%百分号标记

%c字符及其ASCII码

%s字符串

%d有符号整数(十进制)

%u无符号整数(十进制)

%o无符号整数(八进制)

%x无符号整数(十六进制)

%X无符号整数(十六进制大写字符)

%e浮点数字(科学计数法)

%E浮点数字(科学计数法，用E代替e)

%f浮点数字(用小数点符号)

%g浮点数字(根据值的大小采用%e或%f)

%G浮点数字(类似于%g)

%p指针(用十六进制打印值的内存地址)

%n存储输出字符的数量放进参数列表的下一个变量中

八，Number(数字)

• Python支持四种不同的数值类型：

  • 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
  • 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
  • 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
  • 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

• Number类型转换
  int(x ,base) 将x转换为一个整数
  long(x ,base) 将x转换为一个长整数
  （注：这里的base表示参照的进制，比如int(‘20’,3)表示的就是三进制的20；）
  float(x ) 将x转换到一个浮点数
  complex(real，imag) 创建一个复数
  str(x ) 将对象 x 转换为字符串
  repr(x ) 将对象 x 转换为表达式字符串
  eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
  tuple(s ) 将序列 s 转换为一个元组
  list(s ) 将序列 s 转换为一个列表
  chr(x ) 将一个整数转换为一个字符
  unichr(x ) 将一个整数转换为Unicode字符
  ord(x ) 将一个字符转换为它的整数值
  hex(x ) 将一个整数转换为一个十六进制字符串
  oct(x ) 将一个整数转换为一个八进制字符串

Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中，其中math提供了对浮点数的数学运算函数，cmath模块则提供了一些复数运算的函数。与Java一样，要使用函数时必须先导入

import math

python数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
Python包含以下常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

Python三角函数

Python包括以下三角函数：

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

Python数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

九，字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Runoob"

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

var1 = 'Hello World!'
var2 = "Python Runoob"
 
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

结果：var2[1:5]表示var2从1到4

var1[0]:  H
var2[1:5]:  ytho

Python 字符串连接

我们可以对字符串进行截取并与其他字符串进行连接，如下实例：

var1 = 'Hello World!'
print "输出 :- ", var1[:6] + 'Runoob!'

结果：

-  Hello Runoob!

转义字符反斜杠 \

Python字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符	描述	实例
+	字符串连接	>>>a + b ‘HelloPython’
*	重复输出字符串	>>>a * 2 ‘HelloHello’
[]	通过索引获取字符串中字符	>>>a1 ‘e’
[ : ]	截取字符串中的一部分	>>>a[1:4] ‘ell’
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>“H” in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>“M” not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r’\n’ \n >>> print R’\n’ \n

Python 字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
如下实例：

print （"My name is %s and weight is %d kg!" % ('Zara', 21)） 

结果：

My name is Zara and weight is 21 kg!

python 字符串格式化符号:

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%F 和 %E 的简写
%p	用十六进制数格式化变量的地址

Python 三引号

简单解释就是三引号包含的字符穿是可以通过回车来进行换行的。（对于python来说，单引号和双引号没有什么区别，所以三双引号和三单引号也没有区别）
示例

>>> hi = '''hi 
there'''
>>> hi   # repr()
'hi\nthere'
>>> print hi  # str()
hi 
there  

python的字符串内建函数
字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Jython中。
这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。

Python 的字符串常用内建函数

Python 的字符串常用内建函数如下：

方法	描述
capitalize()	将字符串的第一个字符转换为大写
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
count(str, beg= 0,end=len(string)	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding=“utf-8”, errors=“strict”)	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding=‘UTF-8’,errors=‘strict’)	以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()	如果字符串只包含数字则返回 True 否则返回 False…
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()	如果字符串中只包含空白，则返回 True，否则返回 False.
istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
ljust(width[, fillchar])	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
lower()	转换字符串中所有大写字符为小写.
lstrip()	截掉字符串左边的空格或指定字符。
maketrans()	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
replace(old, new , max)	把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找.
rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始.
rjust(width,[, fillchar])	返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
rstrip()	删除字符串末尾的空格或指定字符。
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
splitlines([keepends])	按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
strip([chars])	在字符串上执行 lstrip()和 rstrip()
swapcase()	将字符串中大写转换为小写，小写转换为大写
title()	返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
translate(table, deletechars="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()	转换字符串中的小写字母为大写
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

九，列表与元组

列表元组都与Java相同，索引从0开始，列表和元组内的数据项不需要具有相同的类型，两者的区别在于，列表使用[]中括号，而元组使用小括号(),且列表内的元素可以进行修改，而元组内的元素不能进行修改。

列表

关于列表的索引，熟悉的就是下标从头进行索引，同样的还可以从尾部进行索引，将最后一位定为-1，倒数第二位为-2，示例如下：

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

输出结果：
black
white
yellow

同样的还可以通过中括号[ ]对列表进行截取，示例如下：（注：当然也可以使用符号索引来从尾部进行截取）[开头索引号：结束下一个索引号]冒号：左右可以为空，若空则截取全部。可以比作对一条绳子进行截取，如果对截取的一端没有要求，则这一段直接全部留下，只截取有数据的另外一端。

List=["a","b","c","d"]
print(List[0:2])

输出结果:
[‘a’, ‘b’]

对列表进行更新可以直接进行更改，如果要增加数据则使用append()方法，删除则使用del语句，示例如下：

List=["穆","汪","杨","李"]
print(List[:])
List[0]="穆天傲"
print(List[:])
List.append("小黑")
print(List[:])
del List[4]
print(List[:])

输出结果：
[‘穆’, ‘汪’, ‘杨’, ‘李’]
[‘穆天傲’, ‘汪’, ‘杨’, ‘李’]
[‘穆天傲’, ‘汪’, ‘杨’, ‘李’, ‘小黑’]
[‘穆天傲’, ‘汪’, ‘杨’, ‘李’]

Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

列表还支持拼接操作，示例如下：

List1=[1,2,3,4,5]
List2=[6,7,8,9,0]
List1+=List2
print(List1[:])

输出结果：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

注：列表可以进行嵌套，即列表内元素也可以是列表。
重要函数：
1，返回列表元素个数：len(list)
2，返回列表元素最大值：max(list)
3，返回列表元素最小值：min(list)
4，将元组转换为列表：list(list)
列表重要方法：
1 list.append(obj)
在列表末尾添加新的对象
2 list.count(obj)
统计某个元素在列表中出现的次数
3 list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)
将对象插入列表
6 list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj)
移除列表中某个值的第一个匹配项
8 list.reverse()
反向列表中元素
9 list.sort( key=None, reverse=False)
对原列表进行排序
10 list.clear()
清空列表
11 list.copy()
复制列表

元组

元组虽然不能进行修改，但是可以进行连接组合。
元组虽然不能进行删除，但是可以使用del语句来删除整个元组。与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x,)	1 2 3	迭代

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

Python 表达式	结果	描述
tup1	‘Runoob’	读取第二个元素
tup[-2]	‘Weibo’	反向读取，读取倒数第二个元素
tup[1:]	(‘Runoob’, ‘Taobao’, ‘Wiki’, ‘Weibo’, ‘Weixin’)	截取元素，从第二个开始后的所有元素。
tup[1:4]	(‘Runoob’, ‘Taobao’, ‘Wiki’)	截取元素，从第二个开始到第四个元素（索引为 3）。

元组重要函数：
1，返回列表元素个数：len(tuple)
2，返回列表元素最大值：max(tuple)
3，返回列表元素最小值：min(tuple)
4，将列表转换为元组：tuple(tuple)
5，将元组转换为列表：list(tuple)

十，字典

一个列表可以包含多个字典，比如

data = [{"city":"Taikang","temperature":20},{"city":"Jilin","temperature":0}]

就是键值对，定义时用花括号{ }，比如，d={key1:value1,key2:value2,key3:value3}，注意的点就是键不可变（可以使用数字，字符串以及元组），值可以变（所以可以用列表），修改字典，直接重新赋值即可，删除字典使用del方法，比如del d[key1]来删除键1，del d则删除整个字典。

字典内置函数以及方法

比如radiansdict={“name”:“mutianao”,“age”:22}
1,返回字典长度：len(radiansdict)
2,返回这个字典：str(radiansdict)
3,返回数据类型：type(radiansdict)

方法	描述
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
radiansdict.get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict	如果键在字典dict里返回true，否则返回false
radiansdict.items()	以列表返回一个视图对象
radiansdict.keys()	返回一个视图对象
radiansdict.setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.values()	返回一个视图对象
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem()	随机返回并删除字典中的最后一对键和值。

十一，集合

最重要的就是没有顺序，创建有两种方法，如果创建一个空集合必须用set()，如果创建集合不为空则既可以用set()，也可以用大括号{ }创建，例如：fruit = {‘apple’,‘banana’}或是fruit=set(‘apple’,‘banana’)。

集合的操作：

集合添加元素有两种方法：fruit.add(‘orange’)或是fruit.update(‘oriange’)，两种方法的区别在于update方法添加的参数可以是列表，元组，字典等类型，所以update更全面，所以添加元素时多使用update方法。

集合删除元素的方法也有两种：fruit.remove(‘apple’)和fruit.discard(‘apple’)，两者的区别在于在删除不存在的元素时，remove会报错，而discard不会报错，所以删除时多使用discard方法。

查找元素是否在字典内存在只有一种方法，即’apple’ in fruit，存在则返回True，不存在则返回false。

清空集合则使用clear方法，即fruit.clear()可以实现fruit集合的清空。计算集合内元素个数则使用len函数，即len(fruit返回的即为集合长度。

python中集合内置方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

十二，函数

python定义函数以def开头，传入参数和自变量放在函数标识符后面的圆括号里，并且可以直接在圆括号中定义参数。括号后加冒号：并缩进开始进行函数内容。

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]

函数中的参数类型

不定长参数：你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。基本语法如下：即加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

以上实例输出结果：
70
(60, 50)

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

以上实例输出结果：
10
输出:
70
60
50

还有一种就是参数带两个星号 **，加了两个星号 ** 的参数会以字典的形式导入。示例如下：

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

以上实例输出结果：
1
{‘a’: 2, ‘b’: 3}

声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入。

def test(a,b,*,c):
    return a+b+c
print(test(1,2,c=3))

*号之后的c需要使用关键字传入，所以输出结果：6

总结来说：一个变量前有单星前缀，所有多余的函数参数都会作为一个元组存储在该变量中。如果该变量使用的是双星前缀或是该变量后一个参数为单独的星号，则该变量之后参数传参时需要使用键值对的方式。

强制位置参数：Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。比如对 def f(a, b, /, c, d, *, e, f) 函数传参时只能以 f(10,20,30,d=40,e=50,f=60) 即形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参进行传参。

匿名函数

python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率，所以python中的匿名函数用处不多。

lambda 函数的语法只包含一个语句，如下：

sum = lambda arg1, arg2: arg1 + arg2

调用参数即为sum(10,20)
输出结果为：30

十三，模块

和java导包一模一样，有手就行。

十四，File方法

open()方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。即：open(file, mode=‘r’)，完整写法为open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)。
所有参数说明：
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
mode 参数有：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（Python 3 不支持）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b。

file对象常用的函数

方法	描述
file.close()	关闭文件。关闭后文件不能再进行读写操作。
file.flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.fileno()	返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
file.isatty()	如果文件连接到一个终端设备返回 True，否则返回 False。
file.read([size])	从文件读取指定的字节数，如果未给定或为负则读取所有。
file.readline([size])	读取整行，包括 “\n” 字符。
file.readlines([sizeint])	读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.seek(offset[, whence])	移动文件读取指针到指定位置
file.tell()	返回文件当前位置。
file.truncate([size])	从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
file.write(str)	将字符串写入文件，返回的是写入的字符长度。
file.writelines(sequence)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

十五，异常处理

异常捕获可以使用try，except语句，有以下几种写法：

try:
	...
except...

try:
	...
except...
else...

try:
	...
except...
else...
finally...

try:
	...
except...
except...
else...
finally...
	
try:
	...
finally...

工作方式:首先，执行try子句（在关键字try和关键字except之间的语句）,如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。try except 语句还有一个可选的else子句，如果使用这个子句，那么必须放在所有的except子句之后。这个子句将在try子句没有发生任何异常的时候执行。使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。finally语句块的内容通常是做一些后事的处理，比如资源释放什么的，并且finally语句块是无论如何都要执行的，即使在前面的try和except语句块中出现了return，都现将finally语句执行完再去执行前面的return语句。
一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。转自博客园CloudArrows。

告一段落

入门学习就到这里，永远是这样，风后面是风，天空上面是天空，道路前面还是道路。