一、Python简介
-----------------------------------------------------------
1.Python是一种解释型，面向对象，动态数据类型的高级程序语言
2.像Perl语言一样, Python 源代码同样遵循 GPL(GNU General Public License)协议
二、Python特点
-----------------------------------------
1.Python 是一种解释型语言：
这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
2.Python 是交互式语言：
这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
3.Python 是面向对象语言:
这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
4.Python 是初学者的语言：
Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，
从简单的文字处理到 WWW 浏览器再到游戏。
5.易于学习：
Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
6.易于阅读：
Python代码定义的更清晰。
7.易于维护：
Python的成功在于它的源代码是相当容易维护的。
8.一个广泛的标准库：
Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
9.互动模式：
互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
10.可移植：
基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
11.可扩展：
如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
12.数据库：
Python提供所有主要的商业数据库的接口。
13.GUI编程：
Python支持GUI可以创建和移植到许多系统调用。
14.可嵌入:
你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
三、Ubuntu上Python安装
----------------------------------------
1.Ubuntu已经集成
2.查看Python版本和帮助
$> python -V
$> python --help
3.进入Python的命令行
$> python
>>> print("hello world")
4.编写python脚本文件
$> cat test.py
#!/usr/bin/python
print("hello world")
$> python test.py
hello world
四、Python代码规范
-----------------------------------------------
1.标识符
a.在python里，标识符有字母、数字、下划线组成。
b.在python中，所有标识符可以包括英文、数字以及下划线（_），但不能以数字开头。
c.python中的标识符是区分大小写的。
d.以下划线开头的标识符是有特殊意义的。
以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，
不能用"from xxx import *"而导入；
e.以双下划线开头的（__foo）代表类的私有成员；
以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。
2.行和缩进的格式错误
a.IndentationError: unexpected indent 错误
是python编译器是在告诉你"Hi，老兄，你的文件里格式不对了，可能是tab和空格没对齐的问题"，所有python对格式要求非常严格。
b.如果是 IndentationError: unindent does not match any outer indentation level错误
表明，你使用的缩进方式不一致，有的是 tab 键缩进，有的是空格缩进，改为一致即可。
因此，在Python的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用
3.多行语句
a.Python语句中一般以新行作为为语句的结束符
b.但是我们可以使用斜杠（ \）将一行的语句分为多行显示
total = a + \
b + \
c
c.语句中包含[], {} 或 () 括号就不需要使用多行连接符
totle = { a +
b +
c}
4.引号
Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，
引号的开始与结束必须的相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用语文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sen = "这是一个句子"
para = """这是一个
包含了多个句子的段落"""
5.注释
python的注释是# 开头
#!/usr/bin/python
# 我是一个注释
# 指定编码，解决print打印中文乱码问题
# -*- coding:UTF-8 -*-
print("你好") #注释也可以放在句子后面
'''
我是多行注释
我是多行注释
我是多行注释
'''
"""
我也是多行注释
我也是多行注释
我也是多行注释
"""
6.空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。
类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。
书写时不插入空行，Python解释器运行也不会出错。
但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。
7.标准输入举例
a.等待键盘输入
raw_input("please input a number!")
b.一行多条语句
print 1;print 2;print 3;
c.代码与子句
if True:
print("true")
else:
print("false")
五、变量
------------------------------------------------
1.5种基本类型
a.Numbers
int //a = 10
long
float //a = 10.0
complex //复数 a = 1 + 2j ; a = complex(1,2)
b.String
str = 'Hello World!' # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第五个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str+"TEST" # 输出连接的字符串
c.List
list = ['hello',1,100.0,"world"]
list #输出完整字符串
list[0]
list[0] = 100 #ok
list[1:3]
list[2:]
list * 2
list + list + list
d.Tuple
相当于只读列表，使用(,,)表示，不可二次赋值
t = ( 'runoob', 786 , 70.2 ) #输出完整字符串
t[0] #print
t[0]
t[0] = 5 #wrong
t[1:3]
t[1:]
t[:2]
t * 2
t + t
f.Dictionary
无序集合，通过key存取，{}表示
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
2.类型转换
int(x [,base]) #将x转换为一个整数
long(x [,base] ) #将x转换为一个长整数
float(x) #将x转换到一个浮点数
complex(real [,imag]) #创建一个复数
str(x) #将对象 x 转换为字符串
repr(x) #将对象 x 转换为表达式字符串
eval(str) #计算在字符串中的Python表达式,返回对象
tuple(s) #将序列 s 转换为一个元组
list(s) #将序列 s 转换为一个列表
set(s) #转换为可变集合
dict(d) #创建一个字典。d 必须是一个序列 #(key,value)元组。
frozenset(s) #转换为不可变集合
chr(x) #将一个整数转换为一个字符
unichr(x) #将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) #将一个整数转换为一个十六进制字符串
oct(x) #将一个整数转换为一个八进制字符串
六、运算符
------------------------------------------------
1.算术云算符
+
-
*
/
%
** 幂运算,3**3 = 27
// 整除,5//3 = 1
2.比较运算符
==
!=
<>
<
>
>=
<=
3.赋值运算符
+=
-=
*=
/=
%=
**= 幂运算,3**3 = 27
//= 整除,5 //3 = 1
4.位运算符
& //0 & 1 = 0
| //-1 | 0 = -1
^ //亦或运算。相同为0,不同为1.
~ //取反。
<< //
>> //有符号
5.逻辑运算符
a和b均为boolean类型。
and //a and b 如果ab是int,也可以是按位的与运算,有0为0
or //a or b 如果ab是int,也可以是按位的或运算，有1为1
not //not a
6.成员运算符
in //a and b
not in //a or
list = [1,2,3]
a = 1
a in list //True
a not in list //False
7.身份运算符
身份运算符 判断对象间存储单元的内容
a = 100
b = 100
a is b //True
a is not b //False
七、条件语句
-----------------------------------------------------
1.if
if cond :
xxx
2.if-else
if cond:
xxx
else:
xxx
3.if-elif-else
if cond:
xxx
elif:
xxx
else:
xxx
八、循环语句
------------------------------------------------------
1.打印9*9 for...in...:
rows = [1,2,3,4,5,6,7,8,9]
cols = [1,2,3,4,5,6,7,8,9]
for r in rows:
for c in cols:
if r >= c:
print(str(c) + "*" + str(r) + "=" + str(c * r), end=" ") #不换行，并以“ ”结束
print()
2.while ... break ... continue
print("========== while 循环 ===========")
i = 1
while(i <= 9):
j = 1
while(j <= i):
print("%d * %d = %d" %(i,j,i*j),end="\t")
j += 1
i += 1
print()
九、元组Tuple
-------------------------------------------------------------
1.Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
tup4 = (1,2),(2,3);
tup5 = (1,),(2,);
2.访问元组
元组可以使用下标索引来访问元组中的值,从0开始，
tup2[1:5]
tup2[1]
3.元组的结合
tup3 = tup1 + tup2
4.删除元组
del tup1
5.元组运算符
print(tup2 * 3) #复制三份
print(len(tup2)) # 5
print(tup1 + tup2) #连接操作
print(3 in tup2)
for i in tup2: print(i); #遍历操作
6.函数
len(t1)
max(t1)
min(t1)
tuple(sep)
十、字符串String
----------------------------------------------------
1.字符串格式化输出
print("My name is %s and weight is %d kg!" % ('Zara', 21) )
以上实例输出结果：
My name is Zara and weight is 21 kg!
%c 格式化字符
%s 格式化字符串
%d 格式化整数
%u 无符号整型
%f 格式化浮点
2.r"hello \r\n world"
字符串前面加r表示原样输出，忽视转义
3.Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：
>>> u'Hello World !'
u'Hello World !'
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：
>>> u'Hello\u0020World !'
>>> 'Hello World !'
被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）
十一、列表List
------------------------------------------------------
1.序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
2.修改List
print("========== 结果 ==========")
lst1 = [1,2,3,4,5,6]
print(lst1[2])
lst1[2] = 10
print(lst1[2])
del lst1[2]
print(lst1)
========== 结果 ==========
3
10
[1, 2, 4, 5, 6]
3. + *
print("=======结果=========")
lst2 = [6,7,8,9,0,11]
print(lst1 + lst2)
print(lst1 * 2)
print(lst1[:4])
print(lst1[-2])
========结果========
[1, 2, 4, 5, 6, 6, 7, 8, 9, 0, 11]
[1, 2, 4, 5, 6, 1, 2, 4, 5, 6]
[1, 2, 4, 5]
5
4.函数
len(lst)
max(lst)
min(lst)
list(seq)
lst.pop(i) //不加参数i,表示弹出最后一个元素
lst.append(1) //在结尾追加元素
lst.append(1,4) //在1的位置插入元素
lst.clear() //清空集合
lst.remove(2) //删除指定的元素2,注意不是索引，如果元素不存在，移除的时候会出异常
print("========结果========")
print(lst1)
print(lst1.pop(2))
print(lst1)
print(lst1.remove(6))
print(lst1)
print(lst1.reverse())
print(lst1)
print(lst1.sort())
print(lst1)
========结果========
[1, 2, 4, 5, 6]
4
[1, 2, 5, 6]
None
[1, 2, 5]
None
[5, 2, 1]
None
[1, 2, 5]
5.二维列表
print("============================================")
list_2d = [[1,2],[3,4],[5,6]]
print(list_2d)
rows = [1,2,3,4,5,6,7,8,9]
cols = [1,2,3,4]
list_2d = [[col for col in cols] for row in rows] #row表示外层几个
print(list_2d)
============================================
[[1, 2], [3, 4], [5, 6]]
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
十二、字典表Dictionary
------------------------------------------------------------
1.字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
2.修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
print("============结果=============")
dict0 = {"1":"tom1",2:"tom2",3:"tom3"}
print(dict0)
dict0["1"] = "jerry1" #修改元素
print(dict0)
dict0[1] = "tom1" #增加元素
print(dict0)
del dict0["1"] #删除字典表的“1”
print(dict0)
del dict0 #删除整个字典表
print(dict0[0]) #会出错，因为已经删除了
============结果=============
{'1': 'tom1', 2: 'tom2', 3: 'tom3'}
{'1': 'jerry1', 2: 'tom2', 3: 'tom3'}
{'1': 'jerry1', 2: 'tom2', 3: 'tom3', 1: 'tom1'}
{2: 'tom2', 3: 'tom3', 1: 'tom1'}
3.字典key,value的特性
字典value可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但key不行
不允许同一个key出现两次。创建时如果同一个键被赋值两次，后一个值会被记住,前一个会被覆盖掉
key必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
4.字典表的函数
print("============结果=============")
dict0 = {"1":"tom1",2:"tom2",3:"tom3"}
dict1 = {"1":"tom77","2":"tom2",3:"tom3",4:"tom4"}
print(len(dict0)) #返回字典的长度
print(str(dict0)) #返回字典的字符串表示
print(type(dict0)) #返回字典类型
print(dict0.copy()) #返回字典的一个副本
print(dict0.get("2",50)) #返回字典中key对应的value,如果不存在，就返回后面定义的值
print(dict0.items()) #以元组数组的方式返回一个可遍历的列表
print(dict0.keys()) #返回keys
print(dict0.values()) #返回values
print(dict0.setdefault("2",50)) #返回字典中key对应的value,如果不存在，就返回后面定义的值
print(dict0.update(dict1)) #合并两个字典，相同的键会按照dict1的来
print(dict0) #返回字典中key对应的value,如果不存在，就返回后面定义的值
============结果=============
3
{'1': 'tom1', 2: 'tom2', 3: 'tom3'}
<class 'dict'>
{'1': 'tom1', 2: 'tom2', 3: 'tom3'}
50
dict_items([('1', 'tom1'), (2, 'tom2'), (3, 'tom3')])
dict_keys(['1', 2, 3])
dict_values(['tom1', 'tom2', 'tom3'])
50
None
{'1': 'tom77', 2: 'tom2', 3: 'tom3', '2': 'tom2', 4: 'tom4'}
十三、文件操作
---------------------------------------------------------------
1.输入函数
print("=====================================")
a = input("请输入：")
print(a)
=====================================
请输入：1+2+3
1+2+3
2.open() and readlines()
print("---------------------------------")
a = open("d://calllog.log")
print(a.readline())
lines = a.readlines()
for line in lines :
print(line,end="")
print("---------------------------------")
a = open("d://calllog.log")
while True :
line = a.readline();
if line == "" :
break;
else:
print(line,end="")
open的时候可以指定参数：打开方式，默认是"r"
"r":只读方式打开文件，指针在开头
"rb":以二进制格式打开和只读
"r+":读写，指针位于首
"rb+":二进制，读写，首
"w":只写，已存在覆盖，不存在创建
"wb":二进制，只写
"w+":读写，存在覆盖，不存在创建
"a":只写，追加，存在指针在尾。不存在创建.
"ab":只写，二级制追加
"a+":读写，追加，存在指针在尾。不存在创建.
"ab+":读写，二级制追加
3.write()
file = open("d:\\1.py","w"); #以写的方式打开一个文件，如果文件不存在，就创建一个。如果存在就覆盖
file.write("hello world1111")
4.实现二进制文件的复制
print("==============复制小文件====================")
f1 = open("d:\\1.jpg","rb");
arrStr = f1.read() #读取所有字节
f2 = open("d:\\1_1.jpg","wb");
f2.write(arrStr);
print("==============复制大文件====================")
f1 = open("d:\\1.jpg","rb");
f2 = open("d:\\1_1.jpg","wb");
while True:
buf = f1.read(1024);
if len(buf) != 0:
f2.write(buf)
else:
f1.close()
f2.close()
break;
5.使用os模块
导入包
import os
os.rename(old,new) //文件重命名
os.remove(filename) //移除文件
os.mkdir(dir) //创建目录
os.rmdir(dir) //移除目录
os.chdir(dir) //改变目录
print("==============os 模块====================")
import os
# os.rename("d:\\1.jpg","d:\\a.jpg") #更改目录或者文件名，不能跨磁盘d --> e 是不行的
# os.remove("d:\\1_1.jpg")
# os.mkdir("d:\\py\\data") #次一级目录不能为空，才可以创建完整目录
# os.mkdir("d:\\py\\data\\1.txt") #次一级目录不能为空，才可以创建完整目录.只能创建目录。
# os.remove("d:\\py")
# os.chdir("d:\\py","d:\\py1")
Python基础（一）--- Python简介，特点，代码规范，变量，运算符，条件循环语句，元组，字符串，列表，字典，文件操作
猜你喜欢
转载自blog.csdn.net/xcvbxv01/article/details/83963228
今日推荐
周排行