一 ： Python简介
1 什么是Python
Python是一门优雅而健壮的编程语言，他继承了传统编译语言的强大型和通用性，同时因为借鉴了简单脚本和解释语言的易用性。
2 起源：
Guido van Rossum 于1989年底创始了Python，1991年初，Python发行了第一个公开版本
3 特点：
A 具有高级的数据结构，减少了“框架”开发时间。及标准库模板
B 面向对象：为数据和逻辑相分离的结构化和过程化编程添加了新的活力，面向对象编程支持的行为、特性以及功能与它们要处理或所代表的数据结合在一起
C 可升级：Python中你可以不断地在各个项目中完善你自己的代码，添加额外的新代码。
D 可扩展：Python的标准实现是使用C语言完成的，所以要使用C和C++编写Python扩展，Python的Java实现被称为jython，使用Java进行扩展，还有Ironpython，是针对.NET或Mono 平台的C#实现。
E 可移植性： 可以用于不同的操作系统上的操作，因为Python是用C编写的，因此其继承了C语言的可移植性
F 易学：Python关键字少，结构简单，语法清晰。
G 易读：Python与其他语言显著的差异是：他们有其他语言用来访问变量、定义代码块和进行模式匹配的命令符号，
H 易维护：源代码的维护是软件开发生命周期的组成部分，Python项目的成功很大程度上要归功于其源代码的易于维护
I 健壮性：针对错误Python提供了“安全合理“的退出机制，一旦Python由于崩溃，解释器就会传出一个“堆栈跟踪”。
J 高效的快速原型开发工具，Python有许多面向其他系统的接口，他的功能足够强大，本身也足够强壮，所以完全可以使用Python开发整个系统的原型，Python提供例如强大的扩展库，实现了“即插即用”的标准
K 内存管理器：在Python中，内存管理是由解释器负责的，而C或C++的内存管理是由开发者负责的
L 解释性和字节编译性
Python实际上是字节编译的，其结果就是可以生成一种近似机器语言的中间形式，改善了Python的性能
二 Python解释器
CPython：
IPython：是在CPython的基础上增加了交互式功能
PVPY：
JPython ：基于Java
Ironpython :.NETPython编译工具：
Python，IPython，vim
三 Python 的输入输出：
1 输入：
input（“X：”） 一般针对于数值类型的数据，
执行结果：
raw_input：而非数值类型的数据则使用raw_input进行输入
执行结果
需要添加执行权限：
2 输出：
1 使用print输出各型的
1 字符串
2 整数
3 浮点数
4 初度及精度控制
格式化输出整数
格式化输出16进制整数
%x ---hex 十六进制
%d ---dec 十进制
%o ---oct 八进制
二进制输出结果如下
格式化输出浮点数（float）
其中逗号前面的数字是该字符串的长度，小数点后面的是保留的位数。
2 format 格式化输出
1 位置参数传参,默认为按位置传递参数
In [2]: "a1={},a2={},a3={}".format(1,2,3)
Out[2]: 'a1=1,a2=2,a3=3'
In [3]: "a1={1},a2={2},a3={0}".format(1,2,3)
Out[3]: 'a1=2,a2=3,a3=1'
In [2]: "{0}{1}".format(('www','baidu.com'))
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-2-39bc09eb34c0> in <module>
----> 1 "{0}{1}".format(('www','baidu.com'))
IndexError: tuple index out of range
In [3]: "{0}{1}".format('www','baidu.com')
Out[3]: 'wwwbaidu.com'
In [4]: "{0[0]}{0[1]}".format(('www','baidu.com'))
Out[4]: 'wwwbaidu.com'
2 列表分解
In [7]: l1=[1,2,4,5]
In [8]: "a1={2},a2={3},a3={1},a4={0}".format(*l1)
Out[8]: 'a1=4,a2=5,a3=2,a4=1'3字典分解
In [9]: d1={'k1':'v1','k2':'v3','k3':'v2'}
In [10]: "a1={k2},a2={k1},a3={k3}".format(**d1)
Out[10]: 'a1=v3,a2=v1,a3=v2'4 对齐填充
左对齐，> 表示左填充，10 表示填充的字符长度，'x'表示填充后的结尾，默认填充物是空格
此处可用于生成相关格式化
In [139]: "{:>04}".format(10)
Out[139]: '0010'
In [11]: "{:>10}".format('x')
Out[11]: ' x'
In [12]: "{:*>10}".format('x')
Out[12]: '*********x'右对齐,默认填充物为空格
In [14]: "{:<10}".format('x')
Out[14]: 'x '
In [15]: "{:?<10}".format('x')
Out[15]: 'x?????????'
In [32]: print ("{0}*{1}={2:<2}".format(4,5,4*5),end=" ")
4*5=20
中间对齐
In [16]: "{:?^10}".format('x')
Out[16]: '????x?????'
In [17]: "{:^10}".format('x')
Out[17]: ' x '5 进制转换
In [18]: "{:b}".format(10)
Out[18]: '1010'
In [19]: "{:d}".format(10)
Out[19]: '10'
In [20]: "{:x}".format(10)
Out[20]: 'a'
In [21]: "{:o}".format(10)
Out[21]: '12'6 浮点数格式化
In [23]: "{:.2f}".format(1.2455677)
Out[23]: '1.25'
In [24]: "{:.3f}".format(1.2455677)
Out[24]: '1.246'7 应用
使用列表生成式打印99乘法表
[print ("{}*{}={:>3}{}".format(j,i,i*j,'\n' if i==j else " "),end="") for i in range(1,10) for j in range(1,i+1)] 结果如下
for i in range(1,10):
print ("{:>{}}".format('*',i))
四编码格式：
一般的输入中文时需要指定编码格式为utf-8格式才能输出中文，因为其默认的编码方式是ASCII
个不同编码方式的介绍
ASCII：1个字节表示字符，其一个字节为8位，共有2^8-1=255个不同的编码方式
Unicode： 2个字节表示一个字符，可以包含中文，编码方式为2^16-1=65535种
UTF-8：英文使用一个字节表示一个字符，其他语言使用三个字节进行存储
GB2312
指定编码方式的途径：
coding:utf-8
coding=utf-8
encoding:utf-8
encoding=utf-8
以上几种方式表示的结果是相同的
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
五 数据类型和变量
1 变量
变量是内存中的一块区域
变量的命名：变量名由字母。数字和下划线组成
2 数据类型
1×××：
二进制，八进制，十进制，十六进制（int）
2长整型：
3浮点数：
小数，科学计数法
4 复数：（Python特有）
5 字符串：字符，字符串
6布尔值：Ture,Flase
空值 Null 其不能被理解为0，因为0是有特殊意义的，而None是一个特殊的空值
六 运算符和表达式
1 算数运算符：
+（加） -（减） *(乘) **（次方） /（除） %（余） //
Python 2 和Python中不同的是/ 除 。Python2中5/2=2，而Python 3 中5/2=2.5
2 赋值运算符：
= 、+= 、 -= 、 /=、 *= 、 %= 、
3 关系运算符：
、>=、 <、 <=、 !=、 == 其返回值是一个布尔类型的值
4 逻辑运算符：
and （同真为真） or （同假为假） not （真为假，假为真）
结果为布尔类型
5 位运算
6 成员运算
7 身份运算
8 运算符优先级
七 注释：
单行注释使用#
多行注释使用三引号（''' ''' ）或 （""" """）三引号的作用：
1 用于多行注释：
2 用于print 多行输出
八 内置方法：
1 查找：
如何查找帮助： help(cmp)
类型转化函数： type(x)
2 cmp(1,2)
进行比较大小，前面大于后面为1，相等为0，后面大于前面为-1
3 abs(-1) 取绝对值
4 divmod(10,3) 进行取商和余数
5 pow(X,Y) 其表示为x的y次方
九 Python 语句
1 if 语句格式：
1 if 表达式：
满足表达式执行的语句
2 if 表达式:
满足表达式执行的语句
else:
不满足表达式执行的语句
3 if 表示式：
满足表达式执行的语句
elif 表达式：
满足此表达式执行的语句
......
else：
上面表达式的结果都不满足时执行的结果三目运算符
Python不支持 a>b?a:b
Python支持 a if a>b else b a>b如果成立，则执行a,否则，执行b
———————————————————————————————————————————
2 while 循环语句
用法：
while 表达式：
满足表达式执行的语句
while 表达式：
满足表达式执行的语句
else：
不满足表达式的语句
或使用死循环
while Ture:
所有字句循环语句和用户关键字
break :跳出循环
continue：跳出本次循环
———————————————————————————————————————————
3 生成器对象
range(X,Y)
默认的起始位为0 ，步长为1，结束位为Y-1，可以定义起始，结束和步长。
4 for 循环：
C语言中的for 循环
for（i=0;i<100;i++）
print i
Python中for循环的语法：
for i in 可迭代对象：
state1
跳出for循环：break
跳出本次循环：continue 十 字符串常用操作
1 创建：
单引号，双引号，三引号（转义字符 ： \' \'' \n \t ）
更新
2 特性：
1 索引特性
2 切片特性
s[start:stop:step]
start 默认为0 ，stop默认为字符串长度 ，step默认为1 ，
3 操作符
1 连接操作符（+）
2 重复操作符
3 成员操作符
in ， not in
字符串是可迭代对象，可使用for 实现循环
4 字符串的格式化操作：
1 字符串的格式化符号：
2 格式化操作符辅助指令：
5 字符串常用的方法：
1 判断其字符串是由什么组成
x.isdighit()
2 判断其是有什么开头，什么结尾
注意： 其匹配是一个左闭右开区间。
3 去除空格操作
1 去除开头和结尾的空格
2 去除开头的空格
3 去除结尾空格
4 去除所有空格
4 字符串对齐格式化
左对齐，右对齐，中间对齐
5 按照指令分隔符分离字符串和修改字符串：
split ： 默认替换的是空格
strip([char]) ->str
从字符串两端除去指定的字符集chars中的所有字符，如果char没有指定，去除两边的空白字符
找到能够匹配的字符，直到遇到不能匹配的为止。
其中lsplit 和 lstrip是从左边匹配
rsplit和strip 是从右边匹配
若又多个，则匹配为若有，则匹配，若第二个不满足匹配则后面的皆不匹配
a='www.aaawww.wcom'
a.strip('wac')partition()
从左至右，遇到分割符就将字符串分割为两部分，返回头，分割符，尾部三元组，如果没找到分割符，则就返回头，2个空元素的元组
rpartition()
从右至左，遇到分割符就把字符串分割成两部分，返回头，分割符，尾三部分的元组，如果没有找到分割符，就返回2个空元素和尾部的三元组。
6 指定分隔符连接信息
7 index 索引和 find 发现第一个其结果对应的索引
find在存在其元素时返回其索引，当没有其元素时返回-1
8 查看其字符串长度：
6 枚举法：
与上述相比，枚举法消耗的CPU最少
7 unicode 编码
只需要在字符前面加上一个小写的'u'即可
8 字符串的修改
replace(old,new[],count)
字符串中找到匹配替换为新字符串，并返回新字符串
count 表示替换几次，不指定就是全部替换
判断输入的一串数字中的重复的数字，并将其打印出来
n=input("请输入数字:")
if n.isdigit():
l1=10*[0] #置l1为10位的0，因为数字只有0-9十位。
for i in n:
x=int(i)
if l1[x]== 0: # 当其X对应的元素的值位0时，表示其未计入此判断语句中，若L1[X]不为1时，表示已经统计过了
l1[x]=n.count(i)
print (i,l1[x])
else:
print ("你还输入了其他字符，请重新输入")9 bytes 和 bytearray
1 定义：
字符串与bytes
字符串是字符组成的有序序列，字符可以使用编码来理解
bytes是字节组成的有序不可变序列
bytearray 是字节组成的有序可变序列
2 编码与解码
字符串按照不同的字符集编码encode返回字节序列bytes
encode(encoding='utf8',errors='steict') -> bytes
字节序列按照不同的字符集解码decode返回字符串
bytes.decode(encoding='utf-8',errors='strict') -> str
bytearray.decode(encoding='utf-8',errors='strict') ->str
Unicode是全球编码，对每个国家和地区都有划分
编码 ：
e=bytes('abcd','utf8')
f="abcd".encode()
print (type(e),e,type(f),f)
解码
print (e.decode(),f.decode())
3 bytes 定义
a=bytes() #定义空不可变字节序列
type(a)
b=bytes(10) #定义被0填充的不可变字符序列
print (b,type(b))
c=bytes(range(10)) #定义[0-255]之间的int组成的可迭代对象
d=bytes([10,20,30,40])
print (type(c),c,type(d),d)
使用前缀定义
只允许基本ASCII使用字符形式b'abcd'
使用16进制表示 b"\x41\x61"
4 bytes 操作
bytes 的类型和ste相似，都是不可变数据类型，所以其方法有很多，只不过bytes的方法，输入输出都是bytes
In [3]: b'abc'.find(b'b')
Out[3]: 1
In [4]: b'abcdef'.replace(b'f',b'k')
Out[4]: b'abcdek'类方法 bytes.formhex(string)
string 必须是2个字符的16进制形式,'6162 6a 6b'，空格将会忽略
In [5]: bytes.fromhex('6162 09 6a 6b00')
Out[5]: b'ab\tjk\x00'hex()
返回16进制的字符串
In [9]: 'abc'.encode().hex() # 先转换成字节，然后再转换成16进制
Out[9]: '616263'索引
In [10]: b'abcdef'[1]
Out[10]: 98
In [11]: b'abcdef'[2]
Out[11]: 995 bytearray 定义
a=bytearray() #定义一个空的可变字节序列
print(type(a),a)
b=bytearray(10) # 定义一个被0填充的可变字节序列
print (type(b),b)
c=bytearray([1,2,3,45,67,8]) #定义一个[0,255]的int组成的可迭带对象
d=bytearray(range(10))
print (type(c),c,type(d),d)
e=bytearray('abcd','utf8') # 返回不可变数据类型
f="abcd".encode()
print (type(e),e,type(f),f)
6 bytearray 操作
In [1]: bytearray(b'abcdef').replace(b'f',b'z')
Out[1]: bytearray(b'abcdez')
In [2]: bytearray(b'abcdef').find(b'a')
Out[2]: 0
In [3]: bytearray(b'abcdef').find(b'k')
Out[3]: -1类方法
In [4]: bytearray.fromhex('6162 09 6a 6b00')
Out[4]: bytearray(b'ab\tjk\x00')hex()
返回16进制表示的字符串
In [5]: bytearray('abcd'.encode()).hex()
Out[5]: '61626364'索引
In [8]: bytearray(b'abcdef')[1]
Out[8]: 98
In [9]: bytearray(b'abcdef')[2]
Out[9]: 99
In [10]: bytearray(b'abcdef')[3]
Out[10]: 100bytearray 操作
In [20]: x
Out[20]: bytearray(b'abcdefd')
In [21]: x.append(101) #添加，添加的是整数
In [22]: x
Out[22]: bytearray(b'abcdefde')
In [23]: x.×××ert(0,100) # 插入
In [24]: x
Out[24]: bytearray(b'dabcdefde')
In [25]: x.extend([77,78,79]) # 插入
In [26]: x
Out[26]: bytearray(b'dabcdefdeMNO')
In [26]: x
Out[26]: bytearray(b'dabcdefdeMNO')
In [27]: x.pop() # 弹出
Out[27]: 79
In [28]: x
Out[28]: bytearray(b'dabcdefdeMN')
In [28]: x
Out[28]: bytearray(b'dabcdefdeMN')
In [29]: x.remove(100) # 移除
In [30]: x
Out[30]: bytearray(b'abcdefdeMN')
In [31]: x.clear() # 清空
In [32]: x
Out[32]: bytearray(b'')
In [33]: x=bytearray(b'abcdefg')
In [34]: x.reverse() # 翻转
In [35]: x
Out[35]: bytearray(b'gfedcba')
In [1]: a=bytes(b'abcdef')
In [2]: b=bytearray(a)
In [3]: b.×××ert(0,100)
In [4]: b
Out[4]: bytearray(b'dabcdef')10 python join() 方法
python join() 方法用于将序列中的元素以指定字符串连接生成一个新的字符串
语法
str.join(sequence)
参数
sequence -- 要连接的元素序列
In [1]: str=""
In [2]: seq=['1','2','3','4']
In [3]: str.join(seq)
Out[3]: '1234'
In [4]: "".join(seq) #seq 必须是字符串序列，及可迭代对象中元素类型必须是字符串
Out[4]: '1234'
In [5]: seq=[1,2,3,4,5]
In [6]: "".join(seq)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-6-e5f7e8c88951> in <module>
----> 1 "".join(seq)
TypeError: sequence item 0: expected str ×××tance, int found
In [7]: seq=['1','2','3','4','5']
In [8]: "".join(seq)
Out[8]: '12345'
In [16]: "!".join(seq)
Out[16]: '1!2!3!4!5'十一 元组（带了紧箍咒的列表）
1 元组的创建：
直接进行创建
其后面默认有一个逗号
当创建一个元素时必须在后面加上逗号
使用tuple进行创建无元素的元组
2元组的删除
只能对元组进行整体删除，不能进行逐元素删除
3 元组的操作
1 索引
正向索引
反向索引
多重索引
2 切片
3 连接
4 重复
5 元组个数：
6 成员操作符
in 判断成员是否存在于该组中
7 元素的循环：
可迭代对象（目前已经学习的可迭代对象有 range() 字符串 和 元组）
8 元组可用的内置方法
比较，进行一个一个的比较，当第一个相同时比较第二个，当第一个不同时直接比较出结果，前面大于后面为1，后面大于前面为-1
进行元组内部各元素的比较
元组的转换，可以将其他类型的数据转换成元组：
元组的常用方法
十二 实例
1 99乘法的反向打印
for i in range(9,0,-1):
for j in range(i):
print ("",end="")
for z in range(1,i+1):
print ("{0}*{1}={1:<2}".format(z,i,i*z),end=" ")
print ()
查看结果 
2 打印菱形
分析如下
行数 空格数 打印*数
1 4 (空格长度) 1
2 3 (空格长度) 3 2+1
3 2 (空格长度) 5 3+2
4 1 7 4+3
5 0 9 5+4
6 1 7 6+1
7 2 5 7+-2
8 3 3 8+-5
9 4 1 9+-8for i in range(1,10):
if i<=5:
print ((5-i)*" "+(2*i-1)*"*" + (5-i) *" ")
else:
print ((i-5)*" "+(19-2*i)*"*"+(i-5)*" ")查看结果 
3 打印空心正方形
n=int(input("请输入要打印的正方形的行数"))
for i in range(n):
if i ==0 or i ==n-1:
print ("#"*n)
else:
print ("#"+" "*(n-2)+"#")结果如下
4 打印某数字以内的所有素数
import math
n=int(input("请输入数字:"))
if n==1:
print (1)
elif n==2:
print(1,2)
else:
print (1)
print (2)
for i in range(3,n+1,2): # 其是素数，因此其一定是奇数，除2外
for j in range(2,math.ceil(i**0.5)): #其是素数，其累计到算数平方根后为止。
if i%j==0:
break
else:
print (i)查看结果 
转载于:https://blog.51cto.com/11233559/2055446
扫一扫
31万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
