#斐波那契数列
a,b = 0,1
while a < 1000:
print(a,end=',')
a,b = b,a+b #先计算右边，然后同时赋值到等号左边
同步赋值语句： 同时给多个变量赋值
<变量1>，… ，<变量N>=<表达式1>，… ，<表达式N>
同步赋值会同时运算等号右侧的所有表达式，并一次性且同时将右侧表达式结果分别赋值给左侧的对应变量。
同步赋值的另一个应用是互换变量的值。
>>>x,y = y,x
程序错误：
- 一般来说，只要提示中包含单词”indent“，都是由于缩进不正确造成的，需要检查程序中缩进是否一致。
- 一般来说，只要提示中包含单词”syntax“，都是由于语法格式错误造成的，需要检查程序中语法使用是否正确。
代码缩进：一般以4个空格或Tab键实现，但两者不能混用。
续行符： python提供续行符将单行代码分割为多行表达。续行符由反斜杠（\）符号表达。使用续行符需要注意两点：续行符后不能存在空格，续行符后必须直接换行。
基本输入输出函数：
-
无论用户输入什么内容，input()函数都以字符串类型返回结果。
-
eval(s)函数将去掉字符串s最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容。
eval()函数经常和input()函数一起使用，用来获取用户输入的数字，使用方式如下：
<变量>=eval(input(<提示性文字>))
-
print()函数3种用法：
-
仅用于输出字符串或单个变量，使用方式如下：
print(<待输出字符串或变量>)
对于字符串，print()函数输出后将去掉两侧单引号或双引号。
-
仅用于输出一个或多个变量，使用方式如下：
print(<变量1>，<变量2>，… ,<变量N>)
输出后的各变量值之间用一个空格分隔。
-
用于混合输出字符串与变量值，使用方式如下：
print(<输出字符模板>.format(<变量1>，<变量2>，… ,<变量N>))
print()函数输出文本时默认会在最后增加一个换行，如果不希望换行，或输出文本后增加其他内容，可以对print()函数的end参数进行赋值，print(<待输出内容>，end=”<增加的输出结尾>“)
-
第2章编程题
-
获得用户输入的一个整数N，计算并输出N的32次方。
a = eval(input('请输入一个整数：')) k,n = 1,1 while n <= 32: k *= a n += 1 print(k) -
获得用户输入的一段文字，将这段文字进行垂直输出。
a = input('请输入一段文字：') for i in a: print(i) -
获得用户输入的一个合法算式，例如：1.2+3.4，输出运算结果。
a = input('请输入合法算式：') s = eval(a) print(s) -
获得用户输入的一个小数，提取并输出其整数部分。
a = eval(input('请输入一个小数：')) print(int(a//1)) -
获得用户输入的一个整数N，计算并输出1到N相加的和。
n = eval(input('请输入整数N：')) sum = 0 for i in range(n+1): sum += i print("1到N求和结果：{}".format(sum))
数据类型：
-
数字类型：
包括整数、浮点数和复数。整数可以多种进制表示：不同进制表示的整数是可以直接比较和运算的。
十进制 ： 1089 int()
十六进制：0x3F2 hex()
八进制： 0o1762 oct()
二进制： 0b00110101 bin()
pow(x,y)是Python的内置函数，用来计算xy的值。
Python语言的浮点数运算存在一个”不确定尾数“问题，因为受限于计算机表示浮点数使用的存储宽度，该二进制数并不完全等于浮点数，而是计算机能表示的情况下最接近浮点数的二进制数。不确定尾数问题是所有编程语言的共性问题。
>>>0.1+0.2 0.30000000000000004为了解决不确定尾数问题，可以使用round()函数。
round(x,d)是一个四舍五入函数，能够对x进行带有d位小数的四舍五入运算。由于不确定尾数仅存在于浮点数运算的末尾，可以使用round()函数限定运算结果保留的位数以去掉不确定尾数。
需要注意，”四舍五入“只是一个约定说法，并非所有的.5都会被进位。对于x.5，当x为偶数时，x.5不进位，当x为奇数时，x.5进位。即”奇进偶不进“。但对于x.50001这种非对称情况，则按照进位法则处理。
复数类型 用a+bj表示，虚数部分通过后缀”J“或者"j"来表示。需要注意，当b为1时，1不能省略，即1j表示复数，而单独的j代表的是python程序的变量。
复数类型中实部和虚部都是浮点类型，对于复数z，可以用z.real和z.imag分别获得它的实数部分和虚数部分。
操作符及运算 描述 x+y x与y之和 x-y x与y之差 x*y x与y之积 x/y x与y之商，结果为浮点数 x//y x与y之整数商，即不大于x与y之商的最大整数 x%y x与y之商的余数 -x x的负值 +x x本身 x**y x的y次幂，即xy 本质上，整数的模运算n%m能够将整数n映射到[0,m-1]的区间中。
强赋值操作符（+=、-=、*=、等等）
x op= y等价于x=x op y，但是op和=之间不能有空格。内置的数值运算函数：abs(x) x的绝对值，该函数也可以计算复数的绝对值，即z=a+bj其绝对值abs(z)为 a 2 + b 2 \sqrt{a^2+b^2} a2+b2
max( x 1 x_1 x1, x 2 x_2 x2, ⋯ \cdots ⋯, x n x_n xn) 求 x 1 x_1 x1, x 2 x_2 x2, ⋯ \cdots ⋯, x n x_n xn的最大值
min( x 1 x_1 x1, x 2 x_2 x2, ⋯ \cdots ⋯, x n x_n xn) 求 x 1 x_1 x1, x 2 x_2 x2, ⋯ \cdots ⋯, x n x_n xn的最小值
-
字符串类型：单行字符串采用一对双引号“ ”或者一对单引号’ ‘括起来；多行字符串由一对三单引号’''或一堆三双引号"""括起来。一个中文字符或一个英文字符的长度都记为1。
<模板字符串>.format(<逗号分隔的参数>)
如果字符串中出现的槽的数量和.format方法中出现的变量数量不一致，即程序不能通过简单的顺序对应确定变量使用，则必须在槽中使用序号指定参数使用。
>>>"《论语》是{0}弟子所著。{0}曰：学而时习之，不亦说乎".format("孔子")format()方法的槽除了包含参数序号，还可以包含格式控制信息，语法格式如下：
{<参数序号>:<格式控制标记>}
： <填充> <对齐> <宽度> <，> <.精度> <类型> 引导符号 用于填充的单个字符 < 左对齐
> 右对齐
^ 居中对齐槽的设定输出宽度 数字的千位分隔符适用于整数和浮点数 浮点数小数部分的精度或字符串的最大输出长度 整数类型b,c,d,o,x,X浮点数类型e,E,f,% 字符串处理函数：
len(x) 返回字符串x的长度，也可以返回其他组合数据类型的元素个数
str(x) 返回任意类型x所对应的字符串形式
chr(x)和ord(x)函数用于在单个字符和Unicode编码值之间进行转换。chr(x)返回Unicode编码所对应的字符，ord(x)返回单字符x对应的Unicode编码。
字符串处理方法：
str.lower()及str.upper()将字符串str的全部英文字符变成小写或大写
str.split(sep)根据sep分割字符串str，若sep为空，默认采用空格分隔，sep可以是单个字符也可以是一个字符串。分割后的内容以列表形式返回。
>>>"Python is an excellent language.".split(a) ['Python is','n excellent l','ngu','ge.']str.count(sub) 返回sub子串出现的次数
str.replace(old,new) 将字符串str中出现的old字符串全部替换为new字符串
str.center(width,fillchar) 返回长度为width的字符串。其中，str处于新字符串中心位置，两侧新增字符采用fillchar填充，当width小于字符串长度时，返回str；fillchar是单个字符。
str.strip(chars) 从字符串str中去掉在其左侧和右侧chars中列出的字符。chars是一个字符串，其中出现的每个字符都会被去掉。
str.join(iter) 将str字符串插入iter变量的每个元素之间，形成新的字符串
>>>" ".join('PYTHON') #用空格分割字符串 'P Y T H O H' >>>"".join(['1','2','3','4','5']) #把列表拼接成字符串 '12345'type()的输出
type(‘10.10’)的输出不是字符串”<class ‘str’>“，而是一种内部类型表示，不能采用字符串比较方式进行类型判断。但可以使用type()函数进行直接比较。比如：type(n)==type(123)判断变量n是否是整数类型，type(n)==type(12.12)判断变量n是否是浮点数类型。
类型间转换函数：
int(x) 转换为整数、float(x) 转换为浮点数、str(x) 转换为字符串
浮点数转换为整数类型时，小数部分会被舍弃掉（不使用四舍五入）
第3章编程题
-
获得用户输入的一个整数，输出该整数百位及以上的数字。
a = eval(input("请输入一个整数：")) print(int(a/100)) -
获得用户输入的一个字符串，将字符串按照空格分隔，然后逐行打印出来。
a = input("请输入一个字符串：") b = " ".join(a) print(b) for i in a: print(i) -
程序读入一个表示星期几的数字（1-7），输出对应的星期字符串名称。例如：输入3，返回”星期三“。
a = eval(input("请输入一个数字（1~7）：")) if a==1: b="一" elif a==2: b = "二" elif a == 3: b = "三" elif a==4: b = "四" elif a==5: b = "五" elif a==6: b = "六" elif a==7: b = "日" print('星期{}'.format(b)) -
设n是一个任意自然数，如果n的各位数字反向排列所得自然数与n相等，则n被称为回文数。从键盘输入一个五位数字，请编写程序判断这个数字是否是回文数。
a = input("请输入一个5位数字：") j = len(a) for i in range(len(a)): j -= 1 if a[i] != a[j] : print(a,"不是回文数") break else: print(a,"是回文数") -
输入一个十进制整数，分别输出其二进制、八进制、十六进制字符串。
a = eval(input("请输入一个十进制整数：")) print(a,"的二进制形式：",bin(a),"八进制形式：",oct(a),"十六进制形式：",hex(a))
判断结构：
二分支判断结构还有一种更简洁的表达方式，语法格式为：
<表达式1> if <条件> else <表达式2> 意思是：如果条件成立，则表达式1，否则表达式2
>>>take = " " if s%3==0 and s%5==0 else "不"
表达式和语句：
表达式是产生或计算新数据值的代码片段，它并不是完整语句。例如，99+1是表达式，a=99+1则是语句。
多分支结构：if-elif-else
注意Python会按照多分支结构的代码顺序依次评估判断条件，寻找并执行第一个结果为True条件对应的语句块，当前语句块执行后跳过整个if-elif-else结构。如果没有任何条件成立，else下面的语句块被执行。
Python语言中，任何非零的数值、非空的数据类型都等价于True，0或空类型等价于False，可以直接用作判断条件。
循环结构：
遍历循环：for
for <循环变量> in <遍历结构> ：
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环次数是根据遍历结构中元素个数确定的。
遍历循环还有一种拓展模式，使用方式如下：
for <循环变量> in <遍历结构> ：
<语句块1>
else：
<语句块2>
当for循环正常执行后，程序会继续执行else语句的内容。else语句只在循环正常执行后才执行并结束 ，因此，可以在<语句块2>中放置评价循环执行情况的语句。可以把循环中的else语句想象成一种奖励，当程序辛辛苦苦执行完全部循环，没有中途break终止，则额外给予一段程序执行的奖励。
无限循环：while
n = 0
while n < 10:
print(n)
n = n + 3
无限循环也有一种使用保留字else的扩展模式：
while <条件>：
<语句块1>
else：
<语句块2>
在这种扩展模式中，当while循环正常执行之后，程序会继续执行else语句中的内容。else语句只在循环正常执行之后才执行，因此，可以在<语句块2>中放置评价循环执行情况的语句。
异常处理：
try：
<语句块1>
except：后面可以具体指定错误，也可以不指定，则发生所有类型的错误都执行语句块2
<语句块2>
可以连续使用多个except语句，前面的指明具体错误类型，最后一个处理其余错误。
第4章编程题：
-
输入一个年份，输出是否为闰年。#闰年条件：能被4整除但不能被100整除，或者能被400整除的年份都是闰年。
a = eval(input("请输入一个年份：")) if a%4 == 0 and a%100 != 0 : print(a,'是闰年') elif a%400 == 0 : print(a,'是闰年') else : print(a,'不是闰年') -
求两个整数的最大公约数和最小公倍数。
a = eval(input("请输入整数a：")) b = eval(input("请输入整数b：")) c,d = a,b if b > a : a,b = b,a while a%b != 0 : a,b = b,a%b print(c,d,'两数的最大公约数为：',b) print(c,d,'两数的最小公倍数为：',int(c*d/b)) -
统计不同字符个数。用户从键盘输入一行字符，编写一个程序，统计并输出其中英文字符、数字、空格和其他字符的个数。
a = input("请输入字符串：") w = n = s = e = 0 for i in a: if ord('a') <= ord(i) <= ord("z") or ord('A') <= ord(i) <= ord("Z"): w += 1 elif ord('0') <= ord(i) <= ord("9") : n += 1 elif ord(i) == ord(" ") : s += 1 else : e += 1 print("英文字符个数：",w,"数字个数：",n,"空格个数：",s,"其他字符个数：",e,) -
猜数字游戏续。当用户输入的不是整数（如字母、浮点数等）时，程序会终止执行退出。改编题目1中的程序，当用户输入出错时给出“输入内容必须为整数！”的提示，并让用户重新输入。
while True: try: a = eval(input("请输入一个年份：")) if type(a) != type(123): print('输入内容必须为整数！') continue else : break except: print('输入内容必须为整数！') continue if a%4 == 0 and a%100 != 0 : print(a,'是闰年') elif a%400 == 0 : print(a,'是闰年') else : print(a,'不是闰年') -
羊车门问题。请使用random库对这个随机事件进行预测，分别输出参赛者改变选择和坚持选择获胜的概率。
参考博客：利用Python分析羊车门问题 - Kee1ongZ - 博客园 (cnblogs.com)
import random as r #总次数 total=10000 #1000,1W,10W,100W #换与不换的获胜次数 win1=0 win2=0 for i in range(total): #模拟选择过程 man=r.randint(1,3) car=r.randint(1,3) #结果：一开始为车门，不换+1. # 否则则一开始为羊门，换+1. if man==car: win1+=1 else: win2+=1 print("在{}次实验中：".format(total)) print("若不更改门，获胜概率为{:.3}%.".format((win1/total)*100)) print("若更改门，获胜概率为{:.3}%.".format((win2/total)*100))
函数：
函数可以没有return语句，函数体结束后会将控制权返回给调用者。
函数定义：也叫函数声明，使用def关键字将一段代码定义为函数，需要确定函数名、参数名、参数的个数、使用参数名称作为形式参数编写函数内部的功能代码。
在python中，函数也是有类型的，可以通过type()获得函数类型，函数采用其定义的名字表达，具体为function()类型，这是一种Python的内置类型。然而，如果调用函数，则类型为返回值的类型。
>>>def f(x):
return x+1
>>>type(f)
<class 'function'>
>>>type(f(1))
<class 'int'>
函数的返回值：return语句用来结束函数并将程序返回到函数被调用的位置继续执行。return语句可以出现在函数中的任何部分，return语句可以有多个，即函数可以有多个出口。同时可以将0个、1个或多个函数运算的结果返回给函数被调用处的变量。
多个返回值：当return返回多个值时，这些值形成了一个元组数据类型，由小括号和逗号分隔，可以使用一个变量或多个变量保存结果。
>>>def multiply(x,y):
return x*y,x+y
>>>s=multiply(99,2)
>>>print(s)
(198,101)
>>>a,b=multiply(99,2)
>>>print(a)
198
>>>print(b)
101
变量的作用域：
局部变量：是指在函数内部定义的变量，仅在函数内部有效，当函数退出时变量将不再存在。
全局变量：指在函数之外定义的变量，在程序执行全过程有效。全局变量在函数内部使用时，需要提前使用保留字global声明：global <全局变量>。如果为使用保留字global声明，即使名称相同，也不是全局变量。
第5章编程题：
-
实现isNum()函数，参数为一个字符串，如果这个字符串属于整数、浮点数或复数的表示，则返回True，否则返回False。
def isNum(lstr): try: if type(eval(lstr)) in [type(123),type(12.3),type(3+2j)]: return True else : return False except: return False bool = isNum('yyh') print(bool) -
实现isPrime()函数，参数为整数，要有异常处理。如果整数是质数，返回True，否则，返回False。
def isPrime(num): try: n = int(num) for i in range(2,n): if n % i == 0: return False else : pass else: return True except: print('输入数据有误！') return False bool = isPrime(9) print(bool) -
编写一个函数计算传入字符串中数字、字母、空格以及其它字符的个数。
def count(lstr): char = num = space = some = 0 try: for p in lstr: if ord('a') <= ord(p) <= ord('z') or ord('A') <= ord(p) <= ord('Z'): char += 1 elif ord('0') <= ord(p) <= ord('9'): num += 1 elif ord(p) == ord(' '): space += 1 else : some += 1 print('数字个数：{}，字母个数：{}，空格个数：{}，其它字符个数：{}'.format(num,char,space,some)) return True except: print('输入有误！') return False count('ni hao 233 中文') -
编写一个函数，打印200以内所有素数，以空格分隔。
def printPrime(): try: for n in range(1,201): for i in range(1,n+1): if n % i == 0 and i != 1 and i != n : break else : pass else: print(n, end=" ") except: return False printPrime() -
编写一个函数，参数为一个整数n。利用递归获取斐波那契数列中的第n个数并返回。
def feibo(n): if n == 0: return 0 elif n == 1: return 1 else : return feibo(n-1)+feibo(n-2) print(feibo(3))
集合类型概述：（集合)
集合元素没有索引和位置的概念。
集合中的元素不可重复，元素类型只能是不可变数据类型，例如整数、浮点数、字符串、元组等。相比较而言，列表、字典和集合类型本身都是可变数据类型，不能作为集合的元素出现。
需要注意的是，由于集合元素是无序的，集合的输出顺序与定义顺序可能不一样。
由于集合元素独一无二，使用集合类型可以过滤掉重复元素。
集合元素之间没有顺序，不能比较，不能排序。
集合类型常用的操作函数：
s.add(x) 如果数据项x不在集合s中，将x增加到s
s.remove(x) 如果x在集合s中，移除该元素；不在则产生KeyError异常
s.clear() 移除集合s中所有数据项
set(x)函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。set()函数也可以生成空集合变量。
集合类型主要用于元素去重，适合于任何组合数据类型。
序列类型概述：(字符串、列表、元组)
元素之间存在先后关系，通过序号访问。由于元素之间存在顺序关系，所以序列中可以存在数值相同但位置不同的元素。
序列类型操作符和函数：
x in s，x not in s，s + t，s * n，s[i : j : k]
len(s)，min(s)，max(s)
s.index(x) 序列s中第一次出现元素x的位置。
s.count(x) 序列s中出现x的总次数。
元组类型一旦定义就不能修改，元组类型的所有操作都可以由列表类型实现。因此一般编程中通常以列表类型替代元组类型使用。
元组类型主要在Python语法相关的场景中使用，例如，当函数返回多个值时，多个返回值以元组类型返回，实际上返回一个数据类型。
>>>def f(x):
return x,x+1,x+2
>>>f(1)
(1,2,3)
>>>type(f(1))
<class 'tuple'>
列表类型用中括号（ [ ] ）表示，元素类型可以不同，也可以通过list(x)函数将集合或字符串类型转换成列表类型。list()函数可生成空列表。
>>>list({'201801':'小明','201802':'小红','201803':'小白'})
['201801','201802','201803']
>>>list('Python')
['P','y','t','h','o','n']
列表的操作方法：
除了上述方法外还可以使用Python保留字del对列表元素或片段进行删除
>>>lt = ['1010','10.10','python']
>>>del lt[1] #['1010','python']
ls.copy()复制ls中所有元素生成一个新列表。
>>>lt = ['1010','10.10','python']
>>>ls = lt.copy()
>>>lt.clear() #清空lt
>>>print(ls)
['1010','10.10','python']
由上例看出，一个列表lt使用copy()方法复制后赋值给变量ls，将lt元素清空不影响新生成的变量ls。如果不使用copy()方法，通过直接赋值方式不能产生新列表，仅能够为列表增加一个别名。
>>>lt = ['1010','10.10','python']
>>>ls = lt
>>>lt.clear() #清空lt
>>>print(ls)
[ ]
需要注意，对于基本的数据类型，如整数或字符串，可以通过等号实现元素赋值。但对于列表类型，使用等号无法实现真正的赋值。其中，ls=lt语句并不时拷贝lt中元素给ls，而是新关联了一个引用，即ls和lt所指向的是同一套内容。
a = list(map(int,input("please input :").split())) #将以空格为间隔输入的数字形式字符串转化为数字整型int，并存入列表a。
字典类型的键值对之间没有顺序且不能重复。可以简单的把字典看成元素是键值对的集合。
使用大括号可以创建字典，可以创建一个空字典。通过索引和赋值配合，可以向字典中增加元素。
>>>t = {}
>>>t['201804'] = '小新'
>>>print(t)
{'201804':'小新'}
>>>d = {'201801':'小明','201802':'小红','201803':'小白'}
>>>list(d.keys()) #d.keys()返回结果是内部数据类型，可以将其转化为列表类型方便使用。
['201801','201802','201803']
>>>list(d.values())
['小明','小红','小白']
>>>list(d.items())
[('201801','小明'),('201802','小红'),('201803','小白')]
>>>d.get('201802') #根据键信息查找并返回值信息，key存在则返回相应值，不存在返回默认值
'小红'
>>>d.get('201804','不存在')
'不存在'
>>>del d['201801'] #使用del删除某一元素
>>>print(d)
{'201802':'小红','201803':'小白'}
>>>'201801' in d
True
#文本词频统计,使用字典类型counts={}
if word in counts:
counts[word] = counts[word] + 1
else:
counts[word] = 1
#这个处理逻辑可以更简洁的表示为如下代码：
counts[word] = counts.get(word,0) + 1
第6章编程题：
-
英文字符频率统计。编写一个程序，对于给定字符串中出现的a~z字母频率进行分析，忽略大小写，采用降序方式输出。
lstr = input('please input:') d = {} for c in lstr: if ord('a') <= ord(c) <= ord('z'): d[c] = d.get(c,0) + 1 else : pass print(d) ls = list(d.items()) print(ls) ls.sort(key=lambda x:x[1],reverse=True) print(ls) -
中文字符频率统计。编写一个程序，对给定字符串中出现的全部字符（含中文字符）频率进行分析，采用降序方式输出。
lstr = input('please input:') d = {} for c in lstr: d[c] = d.get(c,0) + 1 print(d) ls = list(d.items()) print(ls) ls.sort(key=lambda x:x[1],reverse=True) print(ls) -
随机密码生成。编写程序在26个字母大小写和9个数字组成的列表中随机生成10个8位密码。
import random l = [chr(ord('a')+i) for i in range(26)] l.extend([chr(ord('A')+i) for i in range(26)]) l.extend([chr(ord('0')+i) for i in range(10)]) for i in range(10): ls = '' for j in range(8): ls += l[random.randint(0,61)] print(ls) -
重复元素判定。编写一个函数，接收列表作为参数，如果一个元素在列表中出现了不止一次，则返回True，但不要改变原列表的值。同时编写调用这个函数和输出测试结果的代码。
lstr = input('please input:') lst = list(lstr) def cfp(lls): d = {} for c in lls: d[c] = d.get(c,0) + 1 ls = list(d.items()) ls.sort(key=lambda x:x[1],reverse=True) if ls[0][1] != 1 return True else: return False a = cfp(lst) print(a) -
重复元素判定续。利用集合的无重复性改编上一个程序，获得一个更快更简洁的版本。
lstr = input('please input:') lst = list(lstr) def cfp(lls): a = len(lls) s = set(lls) b = len(s) if a != b: return True else: return False a = cfp(lst) print(a)
文件操作：
当文件关闭后，再对文件读写将产生I/O操作错误。
f.read()是最常用的一次性读入文件的函数，其结果是一个字符串。
f.readlines()也是一次性读入文件的函数，其结果是一个列表，文件的一行是列表的一个元素。
文件打开后，对文件的读写有一个读取指针，当从文件读入内容后，读取指针将向前进，再次读取的内容将从文件的新位置开始。
f.seek()方法能够移动读取指针的位置，f.seek(0)将读取指针移动到文件开头，f.seek(2)将读取指针移动到文件结尾。
#从文本文件中逐行读入内容并进行处理
f = open(<文件路径及名称>,"r")
for line in f:
#处理一行数据
f.close()
#逐行遍历文件仅针对文本方式，二进制方式打开没有行的概念
f.write(s)向文件写入字符串s。使用f.write(s)时，要显式的使用’\n’对写入文本进行分行，如果不进行分行，每次写入的字符串会被连接起来。
f.writelines(ls)直接将列表类型的各元素接起来写入文件f。
一维数据处理：
逗号分隔的存储格式叫做CSV格式。
#将列表对象写入为CSV格式
ls = ['11','22','33','44']
f = open('num.csv','w')
f.write(','.join(ls))
f.close()
#将CSV格式文件读入为列表
f = open('num.csv','r')
ls = f.read().strip('\n').split(',') #用strip去掉数据尾部的换行符
f.close()
print(ls)
二维数据处理：
二维数据可以采用二维列表来表示，即列表的每个元素仍是一个列表，它对应着二维数据的一行。
#二维列表写入为CSV格式
f = open('cpi.csv','w')
for row in ls: #ls是二维列表 row是二维列表的子列表
f.write(','.join(row)+'\n')
f.close()
#csv格式文件读入为二维列表
f = open('cpi.csv','r')
ls = []
for line in f:
ls.append(line.strip('\n').split(',')) #split()返回的就是一个列表
f.close()
print(ls)
第7章编程题：
-
输入一个文件和一个字符，统计该字符在文件中出现的次数。
def findchar(f,char): count = 0 ls = f.readlines() for line in ls: count += line.count(char) return count f = open("E:/BaiduNetdiskDownload/hahaha.txt","r",encoding='utf-8',errors='ignore') c = findchar(f,"之") print(c) -
假设有一个英文文本文件，编写一个程序读取其内容并将里面的大写字母变成小写字母，小写字母变成大写字母。
def transwrite(f): lstr = f.read() mstr = "" for x in lstr: if "a"<= x <="z": x = chr(ord(x)-32) mstr += x elif "A"<= x <="Z": x = chr(ord(x)+32) mstr += x else : mstr += x f.write("\n") f.write(mstr) f.close() f = open("E:/BaiduNetdiskDownload/hahaha.txt","r+",encoding='utf-8',errors='ignore') transwrite(f) -
编写一个程序，生成一个10x10的随机矩阵并保存为文件（空格分隔行向量、换行分隔列向量）再写程序将刚才保存的矩阵文件另存为csv格式，用excel或文本编辑器打开看看结果对不对。
from numpy import random lstr = "" arr=random.randint(1,20,size=(4,4)) print(arr) for row in arr: for item in row: lstr += str(item) lstr += " " lstr += "\n" f = open("E:/BaiduNetdiskDownload/hahaha.txt","w+",encoding='utf-8',errors='ignore') f.write(lstr) f.close() lstr = lstr.replace(" ",",") f = open("E:/BaiduNetdiskDownload/heihei.csv","w+",encoding='utf-8',errors='ignore') f.write(lstr) f.close() -
编写一个程序，读取一个Python源代码文件，将文件中所有除保留字外的小写字母换成大写字母，生成后的文件能被Python解释器执行。
f = open("E:/BaiduNetdiskDownload/hello.py","r+",encoding='utf-8',errors='ignore') ls = f.read().split() lc = "" lk = [] lm = [] gjz = ['print','in','for','import','and','as','break','if','elif','else','def','continue','except','False','from','global','not','pass'] for items in ls: lk.append(items.split("(")) print(lk) for list in lk: lb = [] for char in list: if char not in gjz: char = char.upper() lb.append(char) else : lb.append(char) lc = "(".join(lb) lm.append(lc) lc = ' '.join(lm) print(lc) f.seek(0) f.write(lc) -
编写一个程序，要求能够将元素为任意Python支持的类型（包含半角逗号的字符串）的列表转储为csv，并能够重新正确解析为列表。
ls = ['haha','12','form','dh,kl'] lb = [] lc = [] for items in ls: items = items.replace(","," /，/") lb.append(items) lstr = ",".join(lb) f = open("E:/BaiduNetdiskDownload/heihei.csv","w+",encoding='utf-8',errors='ignore') f.write(lstr) f.close() f = open("E:/BaiduNetdiskDownload/heihei.csv","r+",encoding='utf-8',errors='ignore') lstr = f.read() lb = lstr.split(",") for items in lb: items = items.replace(" /，/",",") lc.append(items) print(lc)
python官方网站提供了第三方库索引功能，网址如下：
https://pypi.python.org/pypi
最常用最有效的第三方库安装方式是采用pip工具安装。注意要在cmd命令行下执行pip程序，不要在IDLE环境下运行pip。
- pip install <拟安装库名>
- pip的uninstall子命令可以卸载一个已安装的第三方库。
- pip的list子命令可以列出当前系统中已经安装的第三方库。
- pip的show子命令可以列出某个已安装库的详细信息。
- pip的download子命令可以下载第三方库的安装包，但并不安装。
- pip的search子命令可以联网搜索库名或摘要中的关键字。
PyInstaller是一个十分有用的Python第三方库，它能够在Windows、Linux、、Mac os等操作系统下将python源文件（即.py文件）打包，变成直接可运行的可执行文件。
将python程序打包成可执行文件
PyInstaller针对不同的操作系统打包生成的可执行文件都不同。
:\>pyinstaller -F -w xxxx.py
执行完毕后，源文件所在目录将生成dist和build两个文件夹，其中build目录是pyinstaller存储临时文件的目录，可以安全删除。最终的打包程序在dist内部与原文件同名的目录中。
-F参数是要求源文件生成一个独立的可执行文件，无需依赖库。
-w参数是要求可执行文件执行时不打开cmd窗口。
-i <图标文件名.ico> 可以指定生成的可执行文件使用的图标。
第9章编程题：
-
使用turtle库绘制一个蜂窝状六边形。
import turtle as t t.hideturtle() t.pensize(3) t.circle(40,steps=6) x,y = t.pos() t.penup() t.rt(90) t.fd(40) t.left(60) t.fd(40) t.left(30) t.pendown() t.circle(40,steps=6) t.penup() t.goto(x,y) t.rt(90) t.fd(40) t.rt(60) t.fd(40) t.left(150) t.pendown() t.circle(40,steps=6) t.penup() t.goto(x,y) t.left(90) t.fd(40) x,y = t.pos() t.rt(60) t.fd(40) t.pendown() t.rt(30) t.circle(40,steps=6) t.penup() t.goto(x,y) t.left(150) t.fd(40) t.rt(150) t.pendown() t.circle(40,steps=6) t.penup() t.goto(x,y) t.rt(30) t.fd(80) t.left(30) t.pendown() t.circle(40,steps=6) t.penup() t.goto(x,y) t.rt(150) t.fd(80) t.left(150) t.pendown() t.circle(40,steps=6) t.done() -
使用turtle库绘制一朵玫瑰花。
from turtle import * pensize(6) color('red') def write(): fd(60) right(90) fd(130) right(90) fd(60) left(150) fd(60) left(90) fd(130) left(90) fd(60) x,y = pos() right(150) write() for i in range(5): penup() goto(x,y) pendown() left(90) fd(25) x,y = pos() left(180) write() hideturtle() done() -
使用turtle库绘制一个颜色图谱。
from turtle import * setup(1900,1000,0,0) penup() goto(-900,450) pendown() tracer(False) b = 0 for j in range(100): begin_fill() color((1,1,1), (0, 0, b / 100)) b+=1 for i in range(4): fd(15) right(90) end_fill() penup() fd(15) pendown() penup() goto(-900,435) pendown() g = 0 for j in range(100): begin_fill() color((1,1,1), (0, g / 100, 0)) g+=1 for i in range(4): fd(15) right(90) end_fill() penup() fd(15) pendown() penup() goto(-900,420) pendown() r = 0 for j in range(100): begin_fill() color((1,1,1), ( r / 100, 0, 0)) r+=1 for i in range(4): fd(15) right(90) end_fill() penup() fd(15) pendown() done() -
利用random库生成一个包含10个0~100之间随机整数的列表。
import random ls = [] for i in range(10): ls.append(random.randint(0,100)) print(ls) -
利用time库将当前日期转化成类似“Sunday，8.January 2017 11:03PM”的格式。
import time lctime = time.localtime() timestr = time.strftime("%A,%d.%B %Y %I:%M%p",lctime) print(timestr)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
