Python 基础

1、关于continue语句与break语句
continue语句：跳出本次循环

for letter in 'python':
  if letter == 'h':
    continue #continue语句会直接继续下一轮循环，后面的print不会执行
  print('当前字母：',letter)

运行结果

当前字母：p
当前字母：y
当前字母：t
当前字母：o
当前字母：n

var = 10
while var>0:
  var = var - 1
  if var ==5:
    continue
  print("当前变量值：",var)
print("goodbye")

运行结果

当前变量值：9
当前变量值：8
当前变量值：7
当前变量值：6
当前变量值：5
当前变量值：4
当前变量值：3
当前变量值：2
当前变量值：1
当前变量值：0

break语句：跳出整个循环

for letter in 'python':
  if letter == 'h':
    break  #当字母元素等于h时，跳出整个循环，循环体将不再执行
  print("当前字母：",letter)

运行结果

当前字母：p
当前字母：y
当前字母：t

2、pass语句：保持程序结构的完整性，不做任何事情，一般用做站位语句。
在Python中看到一个def函数

def sample(n):
   pass #这里pass占据一个位置

如果定义一个空函数程序会报错，所以用pass填充，使程序可以正常运行
3、Python数学函数

函数	功能描述
abs(x)	返回数字绝对值
fabs(x)	返回数字的绝对值
ceil(x)	返回数字的上入整数，如4.1上入整数为5
floor(x)	返回数字的下舍整数，如4.1下舍整数为4
cmp（x,y）	比较两个数字大小，若x<y返回-1，若x==y返回0，若x>y返回1
exp(x)	返回e的x次幂
max(x1,x2,x3,…)	返回给定参数的最大值，参数可以为序列
min(x1,x2,x3)	返回给定参数的最小值，参数可以为序列
pow(x,y)	计算x**y后的值
round(x,[,n])	返回浮点数x的四舍五入值，如给出n的值，则代表舍入到小数点后的位数
sqrt(x)	返回数字x的平方根
log(x)	math.log(math.e)返回1.0，math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回2.0
modf(x)	返回x的整数部分与小数部分，如参数为4.25返回(0.25,4.0)

modf(x)的用法

import math
s=math.modf(4.25)
print(s)

(0.25,4.0)

round(x,[,n])的用法

print("round(80.23456,2):",round(80.23456,2))

round(80.23456):80.23

4、字符串运算符

操作符	功能描述
+	字符串连接
*	重复输出字符串，如str*2，重复两次输出
[]	通过索引获取字符串中的字符，如str[1]获取位置为1的字符
[:]	截取字符串中的一部分，如str=“Hello”，str[1:4]->>‘ell’
in	成员运算符，若字符串中含有字符，返回True，‘H’ in str->>True
not in	若不包含，返回True，上同

5、Python列表
①列表元素获取

L=['ni','wo','ta']

表达式	描述	结果
L[2]	读取列表中第三个元素	‘ta’
L[-2]	读取列表中倒数第二个元素	‘wo’
L[1:]	从第二个元素开始截取列表	[‘wo’,‘ta’]

②Python列表函数

函数	功能描述
cmp(list1,list2)	比较两个列表的元素，list1>lst2，返回1，list1==list2，返回0
len(list)	求取列表元素的个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

list(seq)的使用

str=(123,'1','2','abc')
list=list(str)
print("列表元素：",list)

运行结果

[123,‘1’,‘2’,‘abc’]

③Python列表方法

方法	描述
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj)	将对象插入列表
list.remove(obj)	移除列表中的某个值的第一个匹配项
list.pop([index=-1])	移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.reverse()	反向列表中元素
list.sort()	对原列表进行排序

list.extend(seq)用法

alist =[123,'1','2','abc']
blist =[345,'3','4','edf']
alist.extend(blist)
print("extend函数使用后的列表变为：",alist)

运行结果

extend函数使用后的列表变为：[123,‘1’,‘2’,‘abc’,345,‘3’,‘4’,‘edf’]

list=['ni','wo','ta']
new=list.pop(1)
print("删除的是：",new)
print("新列表为：",list)

运行结果

删除的是：wo
新列表为：[‘ni’,‘ta’]

list.sort()用法
该方法没有返回值，但会对列表的对象进行排序

list.sort(cmp=None,key=None,reverse=False)

cmp----可选参数，如果sort函数中指定参数会使用该参数的方法进行排序
key----比较元素，指定可迭代对象中一个元素来进行排序
reverse----排序规则，reverse=True降序（从大到小），reverse=False升序（默认）

def takeSecond(elem):
  return elem[1]
random = [(2,2),(3,4),(4,1),(1,3)]
random.sort(key=takeSecond)
print("排序后的列表：",random)

运行结果

排序后的列表：[(4,1),(2,2),(1,3),(3,4)]

6、Python元组
①与列表类似，不同之处在于元组的元素不能修改，元组使用小括号，用逗号隔开，下标索引从0开始，可以进行截取，组合等

tup1=() #创建空元组
tup2=(50,) #元组只包含一个元素时，需要在元素后面添加逗号

tup1=('ni','wo','ta')
tup2=(1,2,3,4,5,6,7)
print("tup1[0]:",tup1[0])
print("tup2[1:5]:",tup2[1:5]) #截取列表，截取下标为1到5的元素，左闭右开，其余舍弃

tup1:ni
tup2:(2,3,4,5)

②元组的元素不能修改但能对元组进行连接

tup1=(1,2,3)
tup2=(4,5,6)
#tup1[0]=100  这里修改元组元素是非法的#
tup3=tup1+tup2 #连接tup1和tup2两个元组

③元组元素值不允许删除，但可以使用del语句来删除整个元组
元组运算符
④元组运算符

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

⑤元素索引、截取、函数与列表一样
7、Python字典
①可变容器模型，且可存任意类型对象，每个键值key=>value对用冒号：分割，每个键之间用逗号,分割，整个字典包括在花括号{}中

d={key1:value1,key2:value2}

键值一般是唯一的，如果重复最后一个键值会替换前面的，值不需要唯一

dict={'a':1,'b':2,'b':'3'}
print(dict['b'])
print(dict) #此时由于重复故前一个key被覆盖，最后输出的是最后一个'b'的

3
{‘a’:1,‘b’:‘3’}

②修改字典

dict ={'Name':'zhang','Age':'19','Class':'First'}
dict['Age']=8 #这里修改更新dict原来的内容
dict['School']="sicnu" #这里添加dict的内容
print("dict['Age']:",dict['Age'])
print(dict)

dict[‘Age’]:8
{‘Name’:‘zhang’,‘Age’:‘19’,‘Class’:‘First’,‘School’:‘sicnu’}

③字典常用方法
mdict={‘H’:1,‘e’:2}

函数	作用	参数	print结果
mdict.clear()	清空mdict的键值对	无	{ }
mdict.copy()	得到字典的一个拷贝	无	{‘H’:1,‘e’:2}
mdict.items()	得到一个list的全部键值对	无	[(‘H’,1),(‘e’,2)]
mdict.keys()	得到一个list的全部键	无	[‘H’,‘e’]
mdict.values()	得到一个list的全部值	无	[1,2]
mdict.update([b])	以b字典更新a字典	{‘H’:3}	{‘H’:3,‘e’:2}
mdict.get(k[,x])	若mdict[k]存在则返回，否则返回x	‘o’,0	0
mdict.setdefault(k[,x])	若k不存在，则添加k:x	‘x’:3	{‘H’:1,‘e’:2,‘x’:3}
mdict.pop(k[,x])	若mdict[k]存在，则删除	H	{‘e’:2}

#给定字符串，统计字符串中各字符出现的次数
mstr="hello world，i am coming"
mlist=list(mstr)
mdict={}
for e in mlist:
    if mdict.get(e,-1)==-1:#没有出现过
       mdict[e]=1
    else:
       mdict[e]+=1
for key,value in mdict.items():
     print(key,value)

8、函数
①函数定义def关键字
②函数调用

def printme(str):
  print (str)
  return
printme("这是我自己的")
printme("再次调用我自己的")

这是我自己的
再次调用我自己的

③Python传不可变对象

def chuancan(a):
    a=10
b=2  #int对象2，指向它的变量是b，在传递给chuancan函数时，按传值的方式复制了变量b，a和b都指向了同一个int对象，在a=10时，新生成一个int值对象10，并让a指向它，所以a和b所指向的内容不同
chuancan(b)
print (b)

2

④传可变对象
传入函数的和在末尾新加新内容的对象用的是同一个引用

def chuancan(list):
    list.append([1,2,3,4])
    print("在函数内:",list)
    return
mylist=[7,8,9]
chuancan(mylist)
print ("在函数外:",mylist)

在函数内:[1,2,3,4,[7,8,9]]
在函数外:[1,2,3,4,[7,8,9]]

⑤不定长参数

def printfo(a,*vartuple):
   print("输出：")
   print(a)
   for var in vartuple:
      print(var)
   return
printfo(10)
printfo(70,60,50)

输出：
10
输出：
70
60
50

⑥匿名函数

sum=lambda arg1,arg2:arg1+arg2
print("10+10=",sum(10,10))

10+10=20

8、Python文件
①读取键盘输入
raw_input:函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
input:基本类型和raw_input相似，但可以接收一个Python表达式作为输入，并将运算结果返回
②打开和关闭文件
open函数：内置函数open()打开一个文件，创建一个file对象

file object = open(file_name[,access_mode][,buffering)

• file_name:该变量是包含了你要访问的文件名称的字符串值
• access_mode:决定了打开文件的模式（只读、写入等等），这个参数实非强制的，默认文件访问模式为只读®
• buffering:如果该值被设为0，就不会有寄存。如果值取1，访问文件时会寄存行。如果设值设为大于1的整数，表明了这就是寄存区的缓冲大小，如果取负值，寄存区的缓冲大小为系统默认。

模式	描述
t
x
b
+
U
r
rb
r+
rb+
w
wb
w+
wb+
a
ab
a+
ab+

③file对象的属性

属性	描述
file.closed	如果返回true文件已被关闭，否则返回false
file.mode	返回被打开文件的访问模式
file.name	返回文件的名称
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true

④close()方法
File对象的close()方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

fileObject.close()

⑤write()方法
将任何字符串写入一个打开的文件，Python字符串可以是二进制数据，而不仅仅是文字

fileObject.write(string) #传入的参数是要写入到已打开文件的内容

#打开一个文件
fo=open("foo.txt","w")
fo.write("the truth that you leave")
#关闭该文件
fo.close()

⑥read()方法
从一个打开的文件中读取一个字符串，如果没有传入count，它会尝试尽可能地读取更多的内容，很可能是直到文件末尾

fileObject.read([count])#传入的参数是要从已打开文件中读取字节计数

f.txt文件保存：“猴子喜欢狮子！”

#文本形式打开文件
tf=open("f.txt","rt")
print(tf.readline())
tf.close()
>>>猴子喜欢狮子！

⑦文件内容的读取
f.txt文件保存：“猴子喜欢狮子！”

操作方法	描述
f.read(size==1)	读入全部内容，如果给出参数，读入前size长度>>>s=f.read(2)>>>猴子
f.readline(size==1)	读入一行内容，如果给出参数，读入该行前size长度>>>s=f.readline>>>猴子喜欢狮子！
f.readlines(hint=-1)	读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行>>>s=f.readlines()>>>[‘猴子喜欢狮子！’]

文件的全文本操作

fname=input("请输入要打开的文件名称：")
fo=open(fname,"r")
txt=fo.read() 
#对全文本txt进行处理
fo.close()
#一次读入，统一处理

 fname=input("请输入要打开的文件名称：")
 fo=open(fname,"r")
 txt=fo.read(2) 
 while txt!="":
    #只要读进来的信息不为空，就一直操作下去
    #对全文本txt进行处理
    txt=fo.read(2)
 fo.close()
 #按数量读入，逐步处理
 #适合处理大文件，常用方法

文件的逐行操作

fname=input("请输入要打开的文件名称:")
fo=open(fname,"r")
for line in fo.readlines():#逐行遍历
    print(line)
fo.close
#一次读入，分行处理
#对于大文件来说，会消耗内存

fname=input("请输入要打开的文件名称:")
fo=open(fname,"r")
for line in fo:#逐行遍历
    print(line)
fo.close
#分行读入，逐行处理

⑧数据的文件写入

操作方法	描述
f.write(s)	向文件写入一个字符串或者字节流 >>>f.write(“猴子喜欢狮子！”)
f.writelines(lines)	将一个元素全为字符串的列表写入文件（并不是分行写入）>>>ls=[“猴子”，“喜欢”,“狮子”]>>>f.writelines(ls)>>>猴子喜欢狮子
f.seek(offset)	改变当前文件操作指针的位置，offset含义如下：0=文件开头；1-当前位置；2-文件结尾>>>f.seek(0)#回到文件开头

数据文件写入

fo=open("output.txt","w+")
ls=["猴子","喜欢","狮子"]
fo.writelines(ls)
for line in fo:
    print(line)#写一个字符串列表
 fo.close()

fo=open("output.txt","w+")
ls=["猴子","喜欢","狮子"]
fo.writelines(ls)
fo.seek(0)
for line in fo:
    print(line)#写一个字符串列表
fo.close()
#写入文件完了后，处理文件指针指向文件后面，for in取出文件的内容打印，已经写过的信息在指针的上方并不是下方。所以用seek调整指针指向位置，返回文件的首位置，遍历文件内容