1.首先是代码中设置的编码问题,可以通过下面两行代码(二选一)解决问题
# coding=utf-8
# -*- coding: UTF-8 -*-
若不添加以上两行代码可能汇出入如下错误
2.然后是控制台中的编码问题,由于我们在代码中设置中文字符串,虽然在代码中设置了utf-8作为编码规范,但是在控制台(vs code)的默认是GBK2312编码,输入chcp可以查到它的编号,(GBK2312的编号是936),那要与代码中的编码匹配,则需要控制台的编码:chcp 65001,如此即可
chcp
#若不为65001,则修改编号
chcp 65001
导入库
找到python安装路径,其中有Scripts文件夹里有一个pip.exe文件,使用命令行进入该文件下,然后
#.\pip install [安装的库],如导入xlrd库:
.\pip install xlrd
以下划线开头的标识符是有特殊意义的。
以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员,以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识,如 init() 代表类的构造函数。
Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。
Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠( \)将一行的语句分为多行显示,如下所示:
item_one = 1
item_two = 2
item_three = 3
total = item_one + \
item_two + \
item_three
print(total)
引号:
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串,引号的开始与结束必须是相同类型的。
注意:三引号可以由多行组成,编写多行文本的快捷语法,常用于文档字符串,在文件的特定地点,被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
注释:
单行注释:#
多行注释:python 中多行注释使用三个单引号(’’’)或三个双引号(""")。——与引号中定义字符串不同的是,字符串都是有名字的。
#这是单行注释
"""
这是多行注释
这是多行注释
这是多行注释
"""
空行:
函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。
同一行显示多条语句:
Python可以在同一行中使用多条语句,语句之间使用分号(;)分割==(并不建议这样做)==
输出:
print 默认输出是换行的,如果要实现不换行需要在变量末尾加上逗号 ,。
x=1
y=2
print(x,y) #当括号中多于一个对象时,这是一种集合输出方式
print(x)
print(y)
print x,y
print x
print y
"""
输出:
(1, 2)
1
2
1 2
1
2
"""
赋值说明:
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
#类型测试
int1 = 1 #这是整型
float1 = 2.0 #这是浮点型
string1 = "hello world" #这是字符型
list1 = ['physics', 'chemistry', 1997, 2000] #这是列表型
tup1 = ('physics', 'chemistry', 1997, 2000) #这是元组
dict1 = {'a': 1, 'b': 2, 'b': '3'} #这是字典
print int1
print float1
print string1
print list1
print tup1
print dict1
print("------以下是类型------")
print(type(int1))
print(type(float1))
print(type(string1))
print(type(list1))
print(type(tup1))
print(type(dict1))
'''
输出:
1
2.0
hello world
['physics', 'chemistry', 1997, 2000]
('physics', 'chemistry', 1997, 2000)
{'a': 1, 'b': '3'}
------以下是类型------
'''
删除:
可以使用del语句删除一些对象的引用。
del语句的语法是:
del var1[,var2[,var3[....,varN]]]]
也可以通过使用del语句删除单个或多个对象的引用。例如:
del var
del var_a, var_b
python数学函数
#python中一些数字函数的用法
import math #在使用数学函数的时候要用到cmath和math库
num1 = -10.2
print "abs函数取数字的绝对值:",abs(num1) #取绝对值,输出10。和fabs库差不多
num2 = 3.14
num3 = 2
num4 = 3
num5 = 4.5
print "ceil函数取数字的向上取整:",math.ceil(num2) #输出4.0
print "cmp函数用于比较数字的大小:",cmp(num1,num2) #num1num2输出1
print "floor函数取数字的向下取整:",math.floor(num2) #输出3.0,返回的是一个浮点数
print "取一个最大值:",max(num1,num2) #输出3.14
print "取一个最小值:",min(num1,num2) #输出-10.2
print "幂次方",pow(2,3) #2的3次方
print "四舍五入:",round(num2),",",round(num5)
print "取根号:",math.sqrt(num3)
python随机数函数
#Python随机数函数
import math
import random #使用random函数就必须导入random包
list2 = list(range(10))
print list2
print "随机选择一个0~10之间的数:",random.choice(list2) #choice(s)函数用于随机选择序列s中的一个数
print "指定递增基数集合中的一个随机数,基数默认值为1: ", random.randrange(100, 1000, 2)
#开始为100,结束为1000,步长为2
print "随机生成一个0~1之间的随机数(后扩展为随机生成一个整数):",int(math.ceil(random.random()*1000))
print "Random number with seed 10 : ", random.random()
random.shuffle(list2) #直接修改序列中的数随机排列
print "将序列中的数随机排列:",list2
print "随机生成一个在一定区间中的数:",random.uniform(1,10)
#seed设置一个种子,设置这个种子后,所有的随机数都在一定的规则中运行
print random.random()
print random.random()
print "------- 设置种子 seed -------"
random.seed( 10 )
print "Random number with seed 10 : ", random.random()
# 生成同一个随机数
random.seed( 10 )
print "Random number with seed 10 : ", random.random()
# 生成同一个随机数
random.seed( 10 )
python的字串列表有2种取值顺序:
如果你要实现从字符串中获取一段子字符串的话,可以使用 [头下标:尾下标] 来截取相应的字符串,其中下标是从 0 开始算起,可以是正数或负数,下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符,但不包含尾下标的字符。
str = 'Hello World!'
print str # 输出完整字符串
print str[0] # 输出字符串中的第一个字符
print str[2:5] # 输出字符串中第三个至第六个之间的字符串
print str[2:] # 输出从第三个字符开始的字符串
print str * 2 # 输出字符串两次
print str + "TEST" # 输出连接的字符串
hi = '''hi
there'''
print hi
"""
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
hi
theres
"""
#字符串拼接
var1 = 'Hello World!'
print "输出 :- ", var1[:6] + 'Runoob!' #字符串用加号拼接
#Python 字符串格式化
print "My name is %s and weight is %d kg!" % ('Zara', 21)
#输出:My name is Zara and weight is 21 kg!
元组和列表的区别:
1.元组使用小括号,列表使用方括号。
2.元组中的元素值是不允许修改的,但列表可以。
3.元组中的元素值是不允许删除的,但列表元素值可以删除。
4.同理,元组没有pop、insert、append等对元组进行修改删除插入的方法或函数。
Python字符串运算符
下表实例变量 a 值为字符串 “Hello”,b 变量值为 “Python”:
操作符 | 描述 | 实例 |
---|---|---|
+ | 字符串连接 | >>>a + b ‘HelloPython’ |
* | 重复输出字符串 | >>>a * 2 ‘HelloHello’ |
[] | 通过索引获取字符串中字符 | >>>a[1] ‘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的字符串内建函数
hello = "hello"
world = "world"
print hello.capitalize() #将字符串的第一个字符大写,不改变原字符类型
print hello.center(11,"=") #第一个参数为整个字符串的长度,第二个参数为将目标字符串居中后,前后字符位置填充的内容
print hello.count('l',0,len(hello)) #统计字符串里某个字符出现的次数
print hello.endswith("o",0,len(hello)) #用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True,否则返回False
print hello.find("lo",0,len(hello)) #检测 str 是否包含在 string 中,返回的是开始时候的索引
print ("第一个字符串:{str1}, 第二个字符串:{str2}".format(str1=hello, str2=world))
print "第一个字符串:%s, 第二个字符串:%s" % (hello , world)
#增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。
print hello.isalnum() #如果 string 至少有 一个字符 并且 所有字符 都是 字母或数字 则返回 True,否则返回 False
print hello.isalpha() #如果 string 至少有 一个字符 并且 所有字符 都是 字母 则返回 True,否则返回 False
str = "-"
seq = ("a", "b", "c") # 字符串序列
print "用join拼接后的数组:",str.join( seq ) #将序列中的元素以指定的字符连接生成一个新的字符串。
#这一部分可以查网址 菜鸟教程:https://www.runoob.com/python/python-strings.html
print hello
"""
输出:
Hello
===hello===
2
True
3
第一个字符串:hello, 第二个字符串:world
第一个字符串:hello, 第二个字符串:world
True
True
用join拼接后的数组: a-b-c
hello
测试python函数
"""
List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
列表用 [ ] 标识,是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。
#列表
list = [ 'hello world', 54 , 3.14, '123', 5.56 ,[111,"123"]]
tinylist = [123, 'john']
plus = [list,tinylist]
print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个元素
print "找到列表最后的元素",list[-1] # 找到列表最后的元素
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表
print list.append("159") # 使用 append() 添加元素
del list[1] # 使用del删除元素
list[1] = 0.168 # 修改列表中的元素
# 一些方法具体参考 菜鸟教程:https://www.runoob.com/python/python-lists.html
print plus
"""
输出:
['hello world', 54, 3.14, '123', 5.56, [111, '123']]
hello world
[54, 3.14]
找到列表最后的元素 [111, '123']
[3.14, '123', 5.56, [111, '123']]
[123, 'john', 123, 'john']
['hello world', 54, 3.14, '123', 5.56, [111, '123'], 123, 'john']
None
[['hello world', 0.168, '123', 5.56, [111, '123'], '159'], [123, 'john']]
"""
元组是另一个数据类型,类似于 List(列表)。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表——相当于不能修改的列表,定义方式不同
#元组——不可修改的列表
tuple = ('hello world', 54 , 3.14, '123', 5.56 ,[111,"123"])
tinytuple = (123, 'john')
plus = (tuple ,tinytuple )
#访问元组
print tuple # 输出完整元组
print tuple [0] # 输出元组的第一个元素
print tuple [1:3] # 输出第二个至第三个元素
print tuple [2:] # 输出从第三个开始至元组末尾的所有元素
#增加元组元素。当前元组元素不允许增加元素,所以要增加元组中的元素要新建元组,把需要添加进去的元素添加
#修改元组元素。当前元组元素不允许增加元素,所以要修改元组中的元素要新建元组
tuple_append = tuple + tinytuple #新的元组
print tinytuple * 2 # 输出元组两次
print tuple_append # 打印组合的元组
#删除元组元素,元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组
print plus
"""
输出:
('hello world', 54, 3.14, '123', 5.56, [111, '123'])
hello world
(54, 3.14)
(3.14, '123', 5.56, [111, '123'])
(123, 'john', 123, 'john')
('hello world', 54, 3.14, '123', 5.56, [111, '123'], 123, 'john')
(('hello world', 54, 3.14, '123', 5.56, [111, '123']), (123, 'john'))
"""
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合,字典是无序的对象集合。
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。类似于Java中的map。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'python','code':3.14, 'dept': [111,"222"]}
#读取数据
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
#增加字典中的映射关系
def Merge(dict1, dict2):
return(dict2.update(dict1))
add_dict = Merge(dict, tinydict) #将第一个参数中的合并到第二个参数的字典中去
print "合并字典,add_dict的值",add_dict,";tinydict的值",tinydict
#修改字典中的映射关系
tinydict["dept"] = 123
print tinydict
#删除字典中的映射关系
del tinydict["dept"] #删除字典中key值为“dept”的键值对
tinydict.clear() #清空整个字典
print tinydict
"""
输出:
This is one
This is two
{'dept': [111, '222'], 'code': 3.14, 'name': 'python'}
['dept', 'code', 'name']
[[111, '222'], 3.14, 'python']
合并字典,add_dict的值 None ;tinydict的值 {'dept': [111, '222'], 2: 'This is two', 'code': 3.14, 'name': 'python', 'one': 'This is one'}
{'dept': 123, 2: 'This is two', 'code': 3.14, 'name': 'python', 'one': 'This is one'}
{}
"""
字典的特性:
1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住
2)键必须不可变,所以可以用数字,字符串或元组充当,所以用列表就不行
函数 | 描述 |
---|---|
int(x,base) | 将x转换为一个整数,base指的是基数 |
float(x) | 将x转换到一个浮点数 |
str(x) | 将对象 x 转换为字符串 |
repr(x) | 将对象 x 转换为表达式字符串 |
tuple(s) | 将序列 s 转换为一个元组 |
list(s) | 将序列 s 转换为一个列表 |
set(s) | 转换为可变集合 |
dict(d) | 创建一个字典。d 必须是一个序列 (key,value)元组。 |
num1 = 3.14
num2 = 6
string = "unittec"
dict_ex = {'runoob': 'dict_ex', 'google': 'google.com'}
list_ex = [123,"list_ex",13.25]
tuple_ex = (458,"tuple_ex",5.56)
toInt = int(num1) #将浮点数强转为整数
toFloat = float(num2) #将整型强转为浮点型
toString = str(num1) #将浮点型强转为字符串
s = repr(dict_ex) #repr() 函数将对象转化为供解释器读取的形式。
toTuple = tuple(list_ex) #tuple(s)是将序列s转为元组模式
toList = list(tuple_ex) #list(s)是将序列s转为列表模式
toSet = set(string) #set(s)是将字符创转化为集合模式
toDict1 = dict(zip(list_ex,toList)) #映射函数方式来构造字典
toDict2 = dict([('one',1),('two',2)]) #可迭代对象方式来构造字典
print "int(x):",toInt
print "float(x):",toFloat
print "str(x):",toString,"===",type(toString)
print "repr(x):",s,"===",type(toString)
print "tuple(s):",toTuple
print "list(s):",toList
print "set(s):",toSet
print "映射方式生成字典:",toDict1
print "迭代方式生成字典",toDict2
"""
int(x): 3
float(x): 6.0
str(x): 3.14 ===
repr(x): {'google': 'google.com', 'runoob': 'dict_ex'}
tuple(s): (123, 'list_ex', 13.25)
list(s): [458, 'tuple_ex', 5.56]
set(s): set(['c', 'e', 'i', 'n', 'u', 't'])
映射方式生成字典: {13.25: 5.56, 123: 458, 'list_ex': 'tuple_ex'}
迭代方式生成字典 {'two': 2, 'one': 1}
"""
算数运算符
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 - 两个对象相加 | a + b 输出结果 30 |
- | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
* | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
/ | 除 - x除以y | b / a 输出结果 2 |
% | 取模 - 返回除法的余数 | b % a 输出结果 0 |
** | 幂 - 返回x的y次幂 | a**b 为10的20次方, 输出结果 100000000000000000000 |
// | 取整除 - 返回商的整数部分(向下取整) | >>> 9//2 4 >>> -9//2 -5 |
Python比较运算符
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
== | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
!= | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
<> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 true。这个运算符类似 != 。 |
> | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
< | 小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。 | (a < b) 返回 true。 |
>= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
<= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
Python赋值运算符
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13,二进制格式如下:
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ,二进制解释: 0000 1100 |
| | 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 | (a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ | 按位异或运算符:当两对应的二进位相异时,结果为1 | (a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ | 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011,在一个有符号二进制数的补码形式。 |
<< | 左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补0。 | a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> | 右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
Python逻辑运算符
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and | x and y | 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or | x or y | 布尔"或" - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not | not x | 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
语法格式:
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
实例:
#if-elif-else
num = 0
while num < 15:
if num % 3 == 0:
print num,"是3的倍数"
elif num % 3 == 1:
print num,"是除3余1的数"
else:
print num,"是除3余2的数"
num += 1
语法格式:
for iterating_var in sequence:
statements(s)
实例:
#for循环
for letter in "qwe":
print "当前字母:",letter
seasons = ["spring","summer","fall","winter"]
nums = (1,2,3,4)
for season in seasons:
print "当前季节为:",season
for num in nums:
print "当前数字是:",num
通过索引迭代:
#for循环中的索引迭代
for index in range(len(seasons)): #range是生成一组序列的意思
print index
print seasons[index]
循环使用 else 语句:
在 python 中,for … else 表示这样的意思,for 中的语句和普通的没有区别,else 中的语句会在循环正常执行完的情况下执行,while … else 也是一样。
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break # 跳出当前循环
else: # 循环的 else 部分
print num, '是一个质数'
循环嵌套:
#第一种嵌套
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
#第二种嵌套
while expression:
while expression:
statement(s)
statement(s)
pass一般用于占位置。
在 Python 中有时候会看到一个 def 函数:
def sample(n_samples):
pass
该处的 pass 便是占据一个位置,因为如果定义一个空函数程序会报错,当你没有想好函数的内容是可以用 pass 填充,使程序可以正常运行。
python可以定义一个函数
可以定义一个由自己想要功能的函数,以下是简单的规则:
1.函数的调用
定义语法:
def printme( str ):
"打印传入的字符串到标准显示设备上"
print str
return
printme("测试python函数")
2.参数传递
在 python 中,类型属于对象,变量是没有类型的:
a=[1,2,3] a="Runoob"
以上代码中,[1,2,3] 是 List 类型,“Runoob” 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是 List 类型对象,也可以指向 String 类型对象。
3.python 传不可变对象实例
# -*- coding: UTF-8 -*-
def ChangeInt( a ):
a = 3
b = 2
ChangeInt(b)
print b # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=3 时,则新生成一个 int 值对象3,并让 a 指向它。
4.python传可变对象实例
# -*- coding: UTF-8 -*-
# 可写函数说明
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]]
"""
上述实例修改的是值本身
5.参数
以下是调用函数时可使用的正式参数类型:
必备参数:必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数:关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
def printme( str ):
"打印任何传入的字符串"
print str
return
#调用printme函数
printme( str = "My string")
默认参数:调用函数时,默认参数的值如果没有传入,则被认为是默认值。
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print "Name: ", name
print "Age ", age
return
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )
不定长参数:可能需要一个函数能处理比当初声明时更多的参数。
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
6.return语句
若没有返回值,直接写return;有返回值就返回返回值
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print "函数内 : ", total
return total
# 调用sum函数
total = sum( 10, 20 )
1.import载入
#import module1[, module2[,... moduleN]]
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
2.from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。
from fib import fibonacci
3.dir()函数
dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块,变量和函数。
import math
content = dir(math)
print content
"""
输出:
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
"""
1.读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本,默认的标准输入是键盘。如下:
# -*- coding: UTF-8 -*-
#raw_input([prompt]) 函数从标准输入读取一个行,并返回一个字符串(去掉结尾的换行符)
str = raw_input("请输入:")
print "你输入的内容是: ", str
#input([prompt]) 函数和 raw_input([prompt]) 函数基本类似,但是 input 可以接收一个Python表达式作为输入,并将运算结果返回。
str = input("请输入:")
print "你输入的内容是: ", str
现在,已经可以向标准输入和输出进行读写。现在,来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
(1)open 函数
首先必须先用Python内置的open()函数打开一个文件,创建一个file对象,相关的方法才可以调用它进行读写。
file object = open(file_name [, access_mode][, buffering])
# file_name:file_name变量是一个包含了你要访问的文件名称的字符串值。
# access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读(r)。
# buffering:如果buffering的值被设为0,就不会有寄存。如果buffering的值取1,访问文件时会寄存行。如果将buffering的值设为大于1的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。
模式 | r | r+ | w | w+ | a | a+ |
---|---|---|---|---|---|---|
读 | + | + | + | + | ||
写 | + | + | + | + | + | |
创建 | + | + | + | + | ||
覆盖 | + | + | ||||
指针在开始 | + | + | + | + | ||
指针在结尾 | + | + |
2.File对象的属性
一个文件被打开后,你有一个file对象,你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表:
属性 | 描述 |
---|---|
file.closed | 返回true如果文件已被关闭,否则返回false。 |
file.mode | 返回被打开文件的访问模式。 |
file.name | 返回文件的名称。 |
file.softspace | 如果用print输出后,必须跟一个空格符,则返回false。否则返回true。 |
# 打开一个文件
#文件IO,在这里遇到一个小问题。
#一个文件如果是用“r”打开出现找不到该文件的错误,用""a+"或“w”方式处理则正常
file = open("mss-project.xls","w",1)
file.close()
print "文件名:",file.name
print "文件是否关闭:",file.closed
print "文件读取方式:",file.mode
print "末尾是否强制加空格",file.softspace
"""
输出:
文件名: mss-project.xls
文件是否关闭: True
文件读取方式: w
末尾是否强制加空格 0
"""
3.close()方法
File 对象的 close()方法刷新缓冲区里任何还没写入的信息,并关闭该文件,这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时,Python 会关闭之前的文件。用 close()方法关闭文件是一个很好的习惯。
语法:
fileObject.close()
4.write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(’\n’):
语法:
fileObject.write(string)
在这里,被传递的参数是要写入到已打开文件的内容。
例子:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 打开一个文件
fo = open("foo.txt", "w")
fo.write( "www.runoob.com!\nVery good site!\n")
# 关闭打开的文件
fo.close()
上述方法会创建foo.txt文件,并将收到的内容写入该文件,并最终关闭文件。
5.read()方法
read()方法从一个打开的文件中读取一个字符串。需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。
语法:
fileObject.read([count])
在这里,被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入,如果没有传入count,它会尝试尽可能多地读取更多的内容,很可能是直到文件的末尾。
例子:
这里我们用到以上创建的 foo.txt 文件。
#打开文件
file_read = open("fileRead.txt","a+")
#读到的字符串要写入的内容
write_file = file_read.read()
file = open("fileWirte.txt","a+")
file.write(write_file)
file.close(
fo.close()
6.文件定位:
#打开文件
file_read = open("fileRead.txt","a+")
#读到的字符串要写入的内容
write_file = file_read.read()
file = open("fileWirte.txt","a+")
file.write(write_file)
#输出文件指针位置
position = file.tell()
print position
# 把指针再次重新定位到文件开头
position = file.seek(0, 0)
string = file.read()
print string
file_read.close()
file.close()
"""
输出:
62
python is a good code language
"""
7.重命名和删除文件:
import os
#重命名文件
os.rename(原来文件,目标文件)
#删除文件
os.remove(文件名)
实例:
import os
#重命名文件
os.rename("fileRead.txt","new_fileRead.txt")
file = open("new_fileRead.txt","a+")
file.close()
#删除文件
os.remove("fileWrite.txt")
print file.name
8.mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。需要提供一个包含了要创建的目录名称的参数。
import os
# 创建目录test
os.mkdir("test")
9.chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是想设成当前目录的目录名称.
# -*- coding: UTF-8 -*-
import os
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
10.rmdir()方法
rmdir()方法删除目录,目录名称以参数传递。
在删除这个目录之前,它的所有内容应该先被清除。
os.remove("F:\\sd\\sd.txt")
os.rmdir("F:\\sd")
11.文件目录相关的方法
rte.txt","a+")
file.write(write_file)
#输出文件指针位置
position = file.tell()
print position
# 把指针再次重新定位到文件开头
position = file.seek(0, 0)
string = file.read()
print string
file_read.close()
file.close()
"""
输出:
62
python is a good code language
"""
7.重命名和删除文件:
import os
#重命名文件
os.rename(原来文件,目标文件)
#删除文件
os.remove(文件名)
实例:
import os
#重命名文件
os.rename("fileRead.txt","new_fileRead.txt")
file = open("new_fileRead.txt","a+")
file.close()
#删除文件
os.remove("fileWrite.txt")
print file.name
8.mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。需要提供一个包含了要创建的目录名称的参数。
import os
# 创建目录test
os.mkdir("test")
9.chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是想设成当前目录的目录名称.
# -*- coding: UTF-8 -*-
import os
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
10.rmdir()方法
rmdir()方法删除目录,目录名称以参数传递。
在删除这个目录之前,它的所有内容应该先被清除。
os.remove("F:\\sd\\sd.txt")
os.rmdir("F:\\sd")
11.文件目录相关的方法
菜鸟教程-python2