python实验(抽象)函数

实验步骤：

1.编写一个类，创建两个数组用于存放从1901到2050年之间所有的闰月，闰年，之后再通过编写几个函数，将阳历转化为阴历，输出即可。

2.根据图形找‘*’，‘’分别与行数i之间的关系及规律，然后用for循环控制输出即可。

3.根据阶乘计算方法用for循环依次计算乘积，直到满足条件为止，然后用if语句控制输出即可。

4.运行程序，根据报错信息发现程序的问题。

5.编写一个函数，用for循环遍历所有三位数，当数符合水仙花条件：一个三位数,其各位数

字立方和等于该数本身，将此数输出即可。

6.编写一个函数，把用户密码设置为一个字符串，将用户输入的密码与设置的密码进行比较，如果相同，输出“密码输入正确！”；如果用户密码里包含‘*’，则不算输入错误，但需要重新输入；其他输入情况都算输入错误，计入输入错误的次数，当用户输入错误次数超过3次时，用户不能再输入密码。

实验结果：

1.>>>

公历2017-12-19

农历冬月初二

2.>>>

please input the number of raw:4

*

* * *

* * * * *

* * * * * * *

3.>>>

1 的阶乘是：1

2 的阶乘是：2

3 的阶乘是：6

4 的阶乘是：24

5 的阶乘是：120

6 的阶乘是：720

7 的阶乘是：5040

8 的阶乘是：40320

9 的阶乘是：362880

10 的阶乘是：3628800

11 的阶乘是：39916800

12 的阶乘是：479001600

13 的阶乘是：6227020800

14 的阶乘是：87178291200

15 的阶乘是：1307674368000

16 的阶乘是：20922789888000

17 的阶乘是：355687428096000

18 的阶乘是：6402373705728000

19 的阶乘是：121645100408832000

20 的阶乘是：2432902008176640000

4.python中函数可以嵌套定义，但在函数内部定义的函数只能在内部使用，外部无法调用

5.>>> water()

水仙花数是：153 370 371 407

6.>>> testify()

please input your password:123456

输入正确！

>>> testify()

please input your password:1

please input your password:2

please input your password:3*

please input your password:4

>>> testify()

please input your password:1

please input your password:2

please input your password:3*

please input your password:4*

please input your password:123456

输入正确！

>>> testify()

please input your password:1

please input your password:1

please input your password:1

疑难小结：

1.输出三角图形时一直报参数类型错，经检查，发现raw_input()是输入字符串，与for循环里的行数n类型不一致，改成input()后解决了此问题。

2.python中函数可以嵌套定义，但在函数内部定义的函数只能在内部使用，外部无法调用

3.阳历转阴历，研究了好久，也没什么头绪。经上网查询资料，大概了解了下阴历，阳历之间的关系，发现还挺复杂的，因为主要需要考虑闰年和闰月的问题。

程序清单：

1.

import datetime

class Lunar(object):

g_lunar_month_day = [

0x4ae0, 0xa570, 0x5268, 0xd260, 0xd950, 0x6aa8, 0x56a0, 0x9ad0, 0x4ae8, 0x4ae0, #1910

0xa4d8, 0xa4d0, 0xd250, 0xd548, 0xb550, 0x56a0, 0x96d0, 0x95b0, 0x49b8, 0x49b0, #1920

0xa4b0, 0xb258, 0x6a50, 0x6d40, 0xada8, 0x2b60, 0x9570, 0x4978, 0x4970, 0x64b0, #1930

0xd4a0, 0xea50, 0x6d48, 0x5ad0, 0x2b60, 0x9370, 0x92e0, 0xc968, 0xc950, 0xd4a0, #1940 0xda50, 0xb550, 0x56a0, 0xaad8, 0x25d0, 0x92d0, 0xc958, 0xa950, 0xb4a8, 0x6ca0, #1950 0xb550, 0x55a8, 0x4da0, 0xa5b0, 0x52b8, 0x52b0, 0xa950, 0xe950, 0x6aa0, 0xad50, #1960

0xab50, 0x4b60, 0xa570, 0xa570, 0x5260, 0xe930, 0xd950, 0x5aa8, 0x56a0, 0x96d0, #1970 0x4ae8, 0x4ad0, 0xa4d0, 0xd268, 0xd250, 0xd528, 0xb540, 0xb6a0, 0x96d0, 0x95b0, #1980

0x49b0, 0xa4b8, 0xa4b0, 0xb258, 0x6a50, 0x6d40, 0xada0, 0xab60, 0x9370, 0x4978, #1990

0x4970, 0x64b0, 0x6a50, 0xea50, 0x6b28, 0x5ac0, 0xab60, 0x9368, 0x92e0, 0xc960, #2000 0xd4a8, 0xd4a0, 0xda50, 0x5aa8, 0x56a0, 0xaad8, 0x25d0, 0x92d0, 0xc958, 0xa950, #2010 0xb4a0, 0xb550, 0xb550, 0x55a8, 0x4ba0, 0xa5b0, 0x52b8, 0x52b0, 0xa930, 0x74a8, #2020

0x6aa0, 0xad50, 0x4da8, 0x4b60, 0x9570, 0xa4e0, 0xd260, 0xe930, 0xd530, 0x5aa0, #2030 0x6b50, 0x96d0, 0x4ae8, 0x4ad0, 0xa4d0, 0xd258, 0xd250, 0xd520, 0xdaa0, 0xb5a0, #2040

0x56d0, 0x4ad8, 0x49b0, 0xa4b8, 0xa4b0, 0xaa50, 0xb528, 0x6d20, 0xada0, 0x55b0, #2050

]

#数组gLanarMonth存放阴历1901年到2050年闰月的月份，如没有则为0，每字节存两年

g_lunar_month = [

0x00, 0x50, 0x04, 0x00, 0x20, #1910

0x60, 0x05, 0x00, 0x20, 0x70, #1920

0x05, 0x00, 0x40, 0x02, 0x06, #1930

0x00, 0x50, 0x03, 0x07, 0x00, #1940

0x60, 0x04, 0x00, 0x20, 0x70, #1950

0x05, 0x00, 0x30, 0x80, 0x06, #1960

0x00, 0x40, 0x03, 0x07, 0x00, #1970

0x50, 0x04, 0x08, 0x00, 0x60, #1980

0x04, 0x0a, 0x00, 0x60, 0x05, #1990

0x00, 0x30, 0x80, 0x05, 0x00, #2000

0x40, 0x02, 0x07, 0x00, 0x50, #2010

0x04, 0x09, 0x00, 0x60, 0x04, #2020

0x00, 0x20, 0x60, 0x05, 0x00, #2030

0x30, 0xb0, 0x06, 0x00, 0x50, #2040

0x02, 0x07, 0x00, 0x50, 0x03 #2050

]

START_YEAR = 1901

# 月份

lm = '正二三四五六七八九十冬腊'

# 日份

ld = '初一初二初三初四初五初六初七初八初九初十十一十二十三十四十五十六十七十八十九二十廿一廿二廿三廿四廿五廿六廿七廿八廿九三十'

def __init__(self, dt = None):

'''初始化：参数为datetime.datetime类实例，默认当前时间'''

self.localtime = dt if dt else datetime.datetime.today()

def ln_year(self): # 返回农历年

year, _, _ = self.ln_date()

return year

def ln_month(self): # 返回农历月

_, month, _ = self.ln_date()

return month

def ln_day(self): # 返回农历日

_, _, day = self.ln_date()

return day

def ln_date(self): # 返回农历日期整数元组（年、月、日）（查表法）

delta_days = self._date_diff()

#阳历1901年2月19日为阴历1901年正月初一

#阳历1901年1月1日到2月19日共有49天

if (delta_days < 49):

year = self.START_YEAR - 1

if (delta_days <19):

month = 11;

day = 11 + delta_days

else:

month = 12;

day = delta_days - 18

return (year, month, day)

#下面从阴历1901年正月初一算起

delta_days -= 49

year, month, day = self.START_YEAR, 1, 1

#计算年

tmp = self._lunar_year_days(year)

while delta_days >= tmp:

delta_days -= tmp

year += 1

tmp = self._lunar_year_days(year)

#计算月

(foo, tmp) = self._lunar_month_days(year, month)

while delta_days >= tmp:

delta_days -= tmp

if (month == self._get_leap_month(year)):

(tmp, foo) = self._lunar_month_days(year, month)

if (delta_days < tmp):

return (0, 0, 0)

return (year, month, delta_days+1)

delta_days -= tmp

month += 1

(foo, tmp) = self._lunar_month_days(year, month)

#计算日

day += delta_days

return (year, month, day)

def ln_date_str(self):# 返回农历日期字符串，形如：农历正月初九

_, month, day = self.ln_date()

return '农历{}月{}'.format(self.lm[month-1], self.ld[(day-1)*2:day*2])

#显示日历

def calendar(self):

pass

#######################################################

# 下面皆为私有函数

#######################################################

def _date_diff(self):

'''返回基于1901/01/01日差数'''

return (self.localtime - datetime.datetime(1901, 1, 1)).days

def _get_leap_month(self, lunar_year):

flag = self.g_lunar_month[(lunar_year - self.START_YEAR) // 2]

if (lunar_year - self.START_YEAR) % 2:

return flag & 0x0f

else:

return flag >> 4

def _lunar_month_days(self, lunar_year, lunar_month):

if (lunar_year < self.START_YEAR):

return 30

high, low = 0, 29

iBit = 16 - lunar_month;

if (lunar_month > self._get_leap_month(lunar_year) and self._get_leap_month(lunar_year)): iBit -= 1

if (self.g_lunar_month_day[lunar_year - self.START_YEAR] & (1 << iBit)):

low += 1

if (lunar_month == self._get_leap_month(lunar_year)):

if (self.g_lunar_month_day[lunar_year - self.START_YEAR] & (1 << (iBit -1))): high = 30

else:

high = 29

return (high, low)

def _lunar_year_days(self, year):

days = 0

for i in range(1, 13):

(high, low) = self._lunar_month_days(year, i)

days += high

days += low

return days

# 返回指定公历日期的儒略日

def _julian_day(self):

ct = self.localtime #取当前时间

year = ct.year

month = ct.month

day = ct.day

if month <= 2:

month += 12

year -= 1

B = year / 100

B = 2 - B + year / 400

dd = day + 0.5000115740 #本日12:00后才是儒略日的开始(过一秒钟)*/

return int(365.25 * (year + 4716) + 0.01) + int(30.60001 * (month + 1)) + dd + B - 1524.5 # 返回指定年份的节气的儒略日数

def _julian_day_of_ln_jie(self, year, st):

s_stAccInfo =[

0.00, 1272494.40, 2548020.60, 3830143.80, 5120226.60, 6420865.80,

7732018.80, 9055272.60, 10388958.00, 11733065.40, 13084292.40, 14441592.00,

15800560.80, 17159347.20, 18513766.20, 19862002.20, 21201005.40, 22529659.80, 23846845.20, 25152606.00, 26447687.40, 27733451.40, 29011921.20, 30285477.60] #已知1900年小寒时刻为1月6日02:05:00

base1900_SlightColdJD = 2415025.5868055555

if (st < 0) or (st > 24):

return 0.0

stJd = 365.24219878 * (year - 1900) + s_stAccInfo[st] / 86400.0

return base1900_SlightColdJD + stJd

# 测试

def test(ct=None):

ln = Lunar(ct)

print('公历{}'.format(ln.localtime.date()))

print('{} '.format(ln.ln_date_str()))

if __name__ == '__main__':

ct = datetime.datetime(2017,12,19)

test(ct)

2.

def rawnum():

n=input("please input the number of raw:")

for i in range(1,n+1):

for j in range(0,n-i):

print u' ',

for k in range(int(2*i-1)):

print u'*',

print u''

rawnum()

3.

def jiecheng(n):

x=1;

if n>=1:

for i in range(1,n+1):

x=x*i

print i,'的阶乘是：',x

else:

return 1

if __name__ == '__main__':

for i in range(1,21):

jiecheng(i)

4.

def outside():

print('I am outside!')

def inside():

print('I am inside!')

inside()

5.

def water():

print '水仙花数是：',

for i in range(100,1000):

x=i/100

y=(i%100)/10

z=i%10

if i==x*x*x+y*y*y+z*z*z:

print i,

6.

def testify():

pwd='123456'

n=1

while(n<=3):

str=raw_input('please input your password:')

if pwd==str:

print '输入正确！'

break

elif '*' in str:

continue

else:

n=n+1

Python常用内置函数总结

Python常用内置函数总结 一、数学相关 1、绝对值：abs(-1) 2、最大最小值：max([1,2,3])、min([1,2,3]) 3、序列长度：len('abc')、len([1,2,3])、len((1,2,3)) 4、取模：divmod(5,2)//(2,1) 5、乘方：pow(2,3,4)//2**3/4 6、浮点数：round(1)//1.0 二、功能相关 1、函数是否可调用：callable(funcname)，注意，funcname变量要定义过 2、类型判断：isinstance(x,list/int) 3、比较：cmp('hello','hello') 4、快速生成序列：(x)range([start,] stop[, step]) 三、类型转换 1、int(x) 2、long(x) 3、float(x) 4、complex(x) //复数 5、str(x) 6、list(x) 7、tuple(x) //元组 8、hex(x) 9、oct(x) 10、chr(x)//返回x对应的字符，如chr(65)返回‘A' 11、ord(x)//返回字符对应的ASC码数字编号，如ord('A')返回65 四、字符串处理 1、首字母大写：str.capitalize 复制代码代码如下:

>>> 'hello'.capitalize() 'Hello' 2、字符串替换：str.replace 复制代码代码如下: >>> 'hello'.replace('l','2') 'he22o' 可以传三个参数，第三个参数为替换次数 3、字符串切割：str.split 复制代码代码如下: >>> 'hello'.split('l') ['he', '', 'o'] 可以传二个参数，第二个参数为切割次数 以上三个方法都可以引入String模块，然后用string.xxx的方式进行调用。 五、序列处理函数 1、len：序列长度 2、max：序列中最大值 3、min：最小值 4、filter：过滤序列 复制代码代码如下: >>> filter(lambda x:x%2==0, [1,2,3,4,5,6]) [2, 4, 6] 5、zip：并行遍历 复制代码代码如下:

Python3 常用函数

Python3 常用函数.笔记 Python 3自学.笔记 type（）检查变量数据： >>> x = 10 >>> type(x) (cla ss ‘int’) exit( ) 执行到此命令时，程序终止：！！！ >>> a = 0 >>> w hile a < 20: a = a + 1 if a == 5: else：#执行到此命令时，程序终止 a = 100 >>> print(a) 5 abs（）返回一个数的绝对值： >>> abs(3) 3 >>> abs(-3) 3 while _ _ _ : 循环执行程序： >>> n = 0 >>> w hile n < 3:#（a n d/o r/n o t） n = n + 1 print(n) Continue 继续下一轮循环 Break 退出整个循环 round（）对小数进行四舍五入操作： >>> x = 3.1415926 >>> round(x , 2) #保留2位小数

3.14 for _ _ _ in _ _ _ : 可以遍历任何序列的项目（如一个列表或者一个字符串）： >>> s = 'a bc def123456' >>> for i in s: print(i) a b c d ...... range( ) 返回一个可迭代对象： >>> range(20) range(0, 20) #默认以0开始 >>> a = 20 >>> for i in ra nge(0 , a , 5): #步长为：5（默认步长为1）print(i) 5 10 15 #计数到20但不包括20 >>> break 退出整个循环： >>> i = 0 >>> w hile i < 10: i = i + 1 if i == 5: Break #执行到此时退出循环结构 >>> print(i) 5 字符串：

最新python常用函数资料

1.map()函数map()是Python 内置的高阶函数，它接收一个函数f和一个list，并通过把函数 f 依次作用在list 的每个元素上，得到一个新的list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数： 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 可以用列表替代 注意：map()函数不改变原有的list，而是返回一个新的list。

利用map()函数，可以把一个list 转换为另一个list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的list，事实上它可以处理包含任意类型的list，只要传入的函数f可以处理这种数据类型。 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart'] format_name(s)函数接收一个字符串，并且要返回格式化后的字符串，利用map()函数，就可以输出新的list。 参考代码: def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT']) 2.reduce()函数 reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和map()类似，一个函数f，一个list，但行为和map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list 的每个元素反复调用函数f，并返回最终结果值。 例如，编写一个f函数，接收x和y，返回x和y的和： def f(x, y): return x + y 调用reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

Python常见数据结构整理

Python常见数据结构整理 2014年10月15日tenking阅读23 次 Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。 一、序列（列表、元组和字符串） 序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。 1、列表 列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。 （1）、创建 通过下面的方式即可创建一个列表： 1 2 3 4list1=['hello','world'] print list1 list2=[1,2,3] print list2 输出： […hello?, …world?] [1, 2, 3] 可以看到，这中创建方式非常类似于javascript中的数组。（2）、list函数

通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效： 1 2list3=list("hello") print list3 输出： […h?, …e?, …l?, …l?, …o?] 2、元组 元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。（1）、创建 1 2 3 4 5 6t1=1,2,3 t2="jeffreyzhao","cnblogs" t3=(1,2,3,4) t4=() t5=(1,) print t1,t2,t3,t4,t5 输出： (1, 2, 3) (…jeffreyzhao?, …cnblogs?) (1, 2, 3, 4) () (1,)从上面我们可以分析得出： a、逗号分隔一些值，元组自动创建完成； b、元组大部分时候是通过圆括号括起来的； c、空元组可以用没有包含内容的圆括号来表示； d、只含一个值的元组，必须加个逗号（,）；（2）、tuple函数

python常用函数年初大总结

1.常用内置函数：(不用import就可以直接使用) help(obj) 在线帮助, obj可是任何类型 callable(obj) 查看一个obj是不是可以像函数一样调用 repr(obj) 得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝 eval_r(str) 表示合法的python表达式，返回这个表达式 dir(obj) 查看obj的name space中可见的name hasattr(obj,name) 查看一个obj的name space中是否有name getattr(obj,name) 得到一个obj的name space中的一个name setattr(obj,name,value) 为一个obj的name space中的一个name指向vale这个object delattr(obj,name) 从obj的name space中删除一个name vars(obj) 返回一个object的name space。用dictionary表示 locals() 返回一个局部name space,用dictionary表示 globals() 返回一个全局name space,用dictionary表示 type(obj) 查看一个obj的类型 isinstance(obj,cls) 查看obj是不是cls的instance issubclass(subcls,supcls) 查看subcls是不是supcls的子类 类型转换函数 chr(i) 把一个ASCII数值,变成字符 ord(i) 把一个字符或者unicode字符,变成ASCII数值 oct(x) 把整数x变成八进制表示的字符串 hex(x) 把整数x变成十六进制表示的字符串

python一些常用方法

1.list方法 一、创建一个列表 只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示： 与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。 二、访问列表中的值 使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示： print"list1[0]:",list1[0] print"list2[1:5]:",list2[1:5] 以上实例输出结果： 三、更新列表 你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示： list=['physics','chemistry',1997,2000]; print"Value available at index2:" print list[2]; list[2]=2001; print"New value available at index2:" print list[2];

以上实例输出结果： 四、删除列表元素 可以使用del语句来删除列表的的元素，如下实例： list1=['physics','chemistry',1997,2000]; print list1; del list1[2]; print"After deleting value at index2:" print list1; 以上实例输出结果： 五、Python列表脚本操作符 列表对+和*的操作符与字符串相似。+号用于组合列表，*号用于重复列表。如下所示： Python表达式结果描述 len([1,2,3])3长度 [1,2,3]+[4,5,6][1,2,3,4,5,6]组合 ['Hi!']*4['Hi!','Hi!','Hi!','Hi!']重复 3in[1,2,3]True元素是否存在于列表中 for x in[1,2,3]:print x,123迭代

Python 常用函数

Python 函数 2016年4月14日 22:07 1、join（）函数 以下实例展示了join()的使用方法： #!/usr/bin/python str ="-"; seq =("a","b","c");# 字符串序列 print str.join( seq ); 以上实例输出结果如下： a-b-c 2、str.zfill(width) 将字符串str前面补0使得字符串长度为width 3、lambda函数（匿名函数） a. lambda表达式返回可调用的函数对象.但不会把这个函 数对象赋给一个标识符,而def则会把函数对象赋值给一个变 量. https://www.wendangku.net/doc/183878412.html,mbda 它只是一个表达式,而def是一个语句 c.定义一些抽象的，不会别的地方再复用的函数 d. lambda语句中,冒号前是参数,可以有多个,用逗号隔开,冒 号右边的返回值 定义了一个lambda表达式，求三个数的和。 用lambda表达式求n的阶乘。 这里也可以把def直接写成lambda形式。如下 lambda函数可以很好和python中内建filter(),map(),reduce()函数的应用程序结合起来,因为它们都带了一个可执行的函数对象. 4、filter(function or None, sequence) -> list, tuple, or string 给定一个'过滤函数'和一个对象的序列,每个序列元素都通过这个过滤器进行筛选,保留函数返回为真的对象.filter函数为已知的序列的每个元素调用给定布尔函数.每个filter返回的非零(true)值元素添加到一个列表中. 1 2 3 #!/usr/bin/python2.5 from random import randint

python中常用的模块的总结

1、模块和包 a.定义： 模块用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），本质就是.py 结尾的python文件。（例如：文件名：test.py,对应的模块名：test） 包：用来从逻辑上组织模块的，本质就是一个目录（必须带有一个__init__.py的文件）b．导入方法 import module_name import module_1的本质：是将module_1解释了一遍 也就是将module_1中的所有代码复制给了module_1 from module_name1 import name 本质是将module_name1中的name变量放到当前程序中运行一遍 所以调用的时候直接print(name)就可以打印出name变量的值 代码例子：自己写的模块，其他程序调用，如下所示: 模块module_1.py代码： 复制代码 1 name = "dean" 2 def say_hello(): 3 print("hello %s" %name) 调用模块的python程序main代码如下：（切记调用模块的时候只需要import模块名不需要加.py） import module_1 #调用变量 print(module_https://www.wendangku.net/doc/183878412.html,)

#调用模块中的方法 module_1.say_hello() 复制代码 这样运行main程序后的结果如下： 1 D:\python35\python.exe D:/python培训/s14/day5/module_test/main.py 2 dean 3 hello dean 4 5 Process finished with exit code 0 import module_name1,module_name2 from module_name import *(这种方法不建议使用) from module_name import logger as log(别名的方法) c.导入模块的本质就是把python文件解释一遍 import module_name---->module_name.py---->module_name.py的路径---->sys.path 导入包的本质就是执行该包下面的__init__.py 关于导入包的一个代码例子： 新建一个package_test包，并在该包下面建立一个test1.py的python程序，在package包的同级目录建立一个p_test.py的程序 test1的代码如下： 1 def test(): 2 print("int the test1") package_test包下的__init__.py的代码如下： 1 #import test1 （理论上这样就可以但是在pycharm下测试必须用下面from .import test1） 2 from . import test1 3 print("in the init") p_test的代码如下： 1 import package_test #执行__init__.py 2 package_test.test1.test()

PYTHON语言常用语法摘要

Python语言常用语法 在Python中有4种类型的数——整数、长整数、浮点数和复数。 使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。 不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。我强烈建议你在每个缩进层次使用单个制表符或两个或四个空格。 在Python中有三种控制流语句——if、for和while。 在Python中没有switch语句。你可以使用if..elif..else语句来完成同样的工作（在某些场合，使用字典会更加快捷。） Break:如果你从for或while循环中终止，任何对应的循环else块将不执行 函数通过def关键字定义。def关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的。 Global定义全局变量。在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。 重要 只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。 这是因为赋给形参的值是根据位置而赋值的。例如，def func(a,b=5)是有效的，但是def func(a=5,b)是无效的。 return语句用来从一个函数返回即跳出函数。我们也可选从函数返回一个值。 pass语句在Python中表示一个空的语句块。 Python有一个很奇妙的特性，称为文档字符串，它通常被简称为docstrings。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！ 文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。强烈建议你在你的函数中使用文档字符串时遵循这个惯例。调用时用print函数名.__doc__(双下划线)。 __name__属性 当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的__name__属性完成。 Dir()函数

Python基本操作题

1.请补充横线处的代码，让Python 帮你随机选一个饮品吧！ import ____①____ (1) listC = ['加多宝','雪碧','可乐','勇闯天涯','椰子汁'] print(random. ____②____ (listC)) 参考答案： import random (1) listC = ['加多宝','雪碧','可乐','勇闯天涯','椰子汁'] print(listC)) 2.请补充横线处的代码，listA中存放了已点的餐单，让Python帮你增加一个“红烧肉”，去掉一个“水煮干丝”。 listA = ['水煮干丝','平桥豆腐','白灼虾','香菇青菜','西红柿鸡蛋汤'] listA. ____①____ ("红烧肉") ②____ ("水煮干丝") print(listA) 参考代码： listA = ['水煮干丝','平桥豆腐','白灼虾','香菇青菜','西红柿鸡蛋汤'] ("红烧肉") ("水煮干丝") print(listA) 3.请补充横线处的代码。dictMenu中存放了你的双人下午套餐（包括咖啡2份和点心2份）的价格，让Python帮忙计算并输出消费总额。 dictMenu = {'卡布奇洛':32,'摩卡':30,'抹茶蛋糕':28,'布朗尼':26} ___①____ for i in ____②____: sum += i print(sum) 参考代码： dictMenu = {'卡布奇洛':32,'摩卡':30,'抹茶蛋糕':28,'布朗尼':26} sum = 0 for i in (): sum += i print(sum) 4.获得输入正整数 N，反转输出该正整数，不考虑异常情况。 参考代码： N = input() print(N[::-1]) 5. 给定一个数字123456，请采用宽度为25、右对齐方式打印输出，使用加号“+”填充。 参考代码： print("{:+>25}".format(123456)) 6.给定一个数字.9，请增加千位分隔符号，设置宽度为30、右对齐方式打印输出，使用空格填充。 参考代码：

python常用函数

1.map()函数 map()是Python 内置的高阶函数，它接收一个函数f和一个list，并通过把函数f 依次作用在li st 的每个元素上，得到一个新的list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方，就可以用map()函数： 因此，我们只需要传入函数f(x)=x*x，就可以利用map()函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 可以用列表替代 注意：map()函数不改变原有的list，而是返回一个新的list。

利用map()函数，可以把一个list 转换为另一个list，只需要传入转换函数。 由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的list，事实上它可以处理包含任意类型的list，只要传入的函数f可以处理这种数据类型。 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list： 输入：['adam', 'LISA', 'barT'] 输出：['Adam', 'Lisa', 'Bart'] format_name(s)函数接收一个字符串，并且要返回格式化后的字符串，利用map()函数，就可以输出新的list。 参考代码: def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT']) 2.reduce()函数 reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和map()类似，一个函数f，一个list，但行为和map()不同，reduce()传入的函数f 必须接收两个参数，reduce()对list 的每个元素反复调用函数f，并返回最终结果值。 例如，编写一个f函数，接收x和y，返回x和y的和： def f(x, y): return x + y 调用reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

python字符串常用函数

字符串常用函数 replace(string,old,new[,maxsplit]) 字符串的替换函数，把字符串中的old替换成new。默认是把string中所有的old值替换成new 值，如果给出maxsplit值，还可控制替换的个数，如果maxsplit为1，则只替换第一个old 值。 >>>a="11223344" >>>print string.replace(a,"1","one") oneone2223344 >>>print string.replace(a,"1","one",1) one12223344 capitalize(string) 该函数可把字符串的首个字符替换成大字。 >>> import string >>> print string.capitalize("python") Python split(string,sep=None,maxsplit=-1) 从string字符串中返回一个列表，以sep的值为分界符。 >>> import string >>> ip="192.168.3.3" >>> ip_list=string.split(ip,'.') >>> print ip_list ['192', '168', '3', '3'] all( iterable) 如果迭代的所有元素都是真就返回真。 >>> l = [0,1,2,3] >>> all(l) Flase >>> l = [1,2,3] >>> all(l) True any( iterable) 如果迭代中有一个元素为真就返回真。 >>> l = [0,1,2,3] >>> all(l) True >>> l = [1,2,3] >>> all(l) True basestring() 这个抽象类型是str和unicode的父类。它不能被调用或初始化，但是它可以使用来测试一

Python编程基础-函数教案

第5章函数 教案 课程名称：Python编程基础 课程类别：必修 适用专业：大数据技术类相关专业 总学时：48学时（其中理论24学时，实验24学时） 总学分：3.0学分 本章学时：9学时 一、材料清单 （1）《Python编程基础》教材。 （2）配套PPT。 （3）代码。 （4）引导性提问。 （5）探究性问题。 （6）拓展性问题。 二、教学目标与基本要求 1.教学目标 主要介绍Python中命名函数的定义方法，从函数定义的格式上可以体现出简练的编程风格，其多种多样的参数设置方式提供了更加灵活的函数定义及调用方法。 2.基本要求 （1）认识自定义函数，了解自定义函数的调用。

（2）掌握函数的参数设置及返回函数（return函数）。 （3）掌握嵌套函数。 （4）掌握局部变量和全局变量的区别。 （5）掌握匿名函数和其他高阶函数的使用方法。 （6）掌握存储并导入函数模块的方法。 三、问题 1.引导性提问 引导性提问需要教师根据教材内容和学生实际水平，提出问题，启发引导学生去解决问题，提问，从而达到理解、掌握知识，发展各种能力和提高思想觉悟的目的。 （1）用于练习的所有资料都放在您面前了吗？如果不是，缺少哪些？ （2）Python中函数和方法有什么不同？ （3）什么是封装？ （4）匿名函数是什么？ （5）函数与模块有什么关系？ 2.探究性问题 探究性问题需要教师深入钻研教材的基础上精心设计，提问的角度或者在引导性提问的基础上，从重点、难点问题切入，进行插入式提问。或者是对引导式提问中尚未涉及但在课文中又是重要的问题加以设问。 （1）自定义函数中参数类型有哪些？有什么区别？ （2）print函数与rerun函数有什么区别？ （3）自定义函数的调用方式有哪些？ （4）嵌套函数与嵌套循环一样吗？ （5）局部变量与全局变量有什么区别？ （6）如何用全局变量替换局部变量？ （7）高阶函数生成的是什么数据结构？

Python基本操作题

1.请补充横线处的代码，让 Python 帮你随机选一个饮品吧！ import ____①____ (1) listC = ['加多宝','雪碧','可乐','勇闯天涯','椰子汁'] print(random. ____②____ (listC)) 参考答案： import random (1) listC = ['加多宝','雪碧','可乐','勇闯天涯','椰子汁'] print(listC)) 2.请补充横线处的代码，listA中存放了已点的餐单，让Python帮你增加一个“红烧肉”，去掉一个“水煮干丝”。 listA = ['水煮干丝','平桥豆腐','白灼虾','香菇青菜','西红柿鸡蛋汤'] listA. ____①____ ("红烧肉") ②____ ("水煮干丝") print(listA) 参考代码： listA = ['水煮干丝','平桥豆腐','白灼虾','香菇青菜','西红柿鸡蛋汤'] ("红烧肉") ("水煮干丝") print(listA) 3.请补充横线处的代码。dictMenu中存放了你的双人下午套餐（包括咖啡2份和点心2份）的价格，让Python帮忙计算并输出消费总额。 dictMenu = {'卡布奇洛':32,'摩卡':30,'抹茶蛋糕':28,'布朗尼':26} ___①____ for i in ____②____: sum += i print(sum) 参考代码： dictMenu = {'卡布奇洛':32,'摩卡':30,'抹茶蛋糕':28,'布朗尼':26} sum = 0 for i in (): sum += i print(sum) 4.获得输入正整数N，反转输出该正整数，不考虑异常情况。 参考代码： N = input() print(N[::-1]) 5. 给定一个数字 123456，请采用宽度为 25、右对齐方式打印输出，使用加号“+”填充。 参考代码： print("{:+>25}".format(123456)) 6.给定一个数字.9，请增加千位分隔符号，设置宽度为30、右对齐方式打印输出，使用空格填充。 参考代码：

Python 函数文件与模块

Python 函数、文件与模块 “探索Python” 这一系列的前几篇文章已为Python 编程新手介绍了几方面的主题，包括变量、容器对象和复合语句。本文以这些概念为基础，构造一个完整的Python 程序。引入了Python 函数和模块，并展示了构建一个Python 程序、将其存储在文件中以及通过命令行运行该程序的方法。 返璞归真 许多流行的玩具都以这样一个概念为基础：简单的积木。这些简单的积木可通过多种方式组合在一起构造出全新的作品——有时甚至完全令人出乎意料。这一概念同样适用于现实生活中的建筑领域，将基本原材料组合在一起，形成有用的建筑物。平凡无奇的材料、技术和工具简化了新建筑物的建造过程，同样也简化了对新踏入此领域的人员的培训。 相同的基本概念也适用于计算机程序开发技术，包括以Python 编程语言编写的程序。本文介绍了使用Python 创建基本构件(building block) 的方法，可用于解决更为复杂的问题。这些基本构件可能小而简单，也可能庞大而复杂。无论采用哪种形式，我们这场游戏的目的就是定义基本构件，然后使用它们来创建专属于您的杰作。 函数：封装逻辑 在本系列的前几篇文章中，您通常不得不重复输入所有代码，即便它与上一行代码完全相同。此要求的惟一特例就是变量的使用：一旦初始化了变量的内容，之后就可以随时重用。显而易见，这一用法的普及对我们大有好处。 描述杰出程序员的最流行的箴言之一就是他们很懒惰。这并不表示杰出的程序员不努力工作——而是说他们喜欢灵活的工作方法，除非绝对必要，否则从不反复做任何相同的事情。这也就意味着在您需要编写代码之前，首先考虑如何实现重用。Python 中有多种可实现重用的途径，但最简单的技术莫过于使用函数，也称为方法或子例程。 与绝大多数现代编程语言类似，Python 支持使用方法将一组语句封装在一起，从而可在必要时重复使用。清单1 给出了一段简单的伪代码，为您展示如何在Python 中编写方法。

python常用函数

1.map() 函数 map() 是 Python 内置的高阶函数，它接收一个函数f 和一个 list ，并通过把函数 f 依次作用在li st 的每个元素上，得到一个新的list 并返回。 例如，对于 list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把 list 的每个元素都作平方，就可以用map() 函数： 因此，我们只需要传入函数f(x)=x*x ，就可以利用map() 函数完成这个计算： def f(x): return x*x print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) 输出结果： [1, 4, 9, 10, 25, 36, 49, 64, 81] 可以用列表替代 注意： map() 函数不改变原有的list ，而是返回一个新的 list 。

利用 map() 函数，可以把一个list 转换为另一个list ，只需要传入转换函数。 由于 list 包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list ，事实上它可以处理包含任意类型的list ，只要传入的函数 f 可以处理这种数据类型。 假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则，请利用map() 函数， 把一个 list （包含若干不规范的英文名字）变成一个包含规范英文名字的list ： 输入： ['adam', 'LISA', 'barT'] 输出： ['Adam', 'Lisa', 'Bart'] format_name(s) 函数接收一个字符串，并且要返回格式化后的字符串，利用map() 函数，就可以输 出新的 list 。 参考代码 : def format_name(s): return s[0].upper() + s[1:].lower() print map(format_name, ['adam', 'LISA', 'barT']) 2.reduce() 函数 reduce() 函数也是 Python 内置的一个高阶函数。reduce() 函数接收的参数和map() 类似，一个函 数 f ，一个 list ，但行为和map() 不同， reduce() 传入的函数 f 必须接收两个参数，reduce() 对 list 的每个元素反复调用函数f，并返回最终结果值。 例如，编写一个 f 函数，接收x 和 y，返回 x 和 y 的和： def f(x, y): return x + y

(完整版)python常用函数

1. map() 函数 map() 是Python 内置的高阶函数，它接收一个函数f 和一个list ，并通过把函数 f 依次作用在list 的每个元素上，得到一个新的list 并返回。 例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list 的每个元素都作平方，就可以用map()函数： 输出结果： 可以用列表替代 注意：map() 函数不改变原有的list ，而是返回一个新的list 。 利用map()函数，可以把一个list 转换为另一个list ，只需要传入转换函数。 由于list 包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的list ，事实上它可以处理包含任意类型的list ，只要传入的函数 f 可以处理这种数据类型。 format_name(s) 函数接收一个字符串，并且要返回格式化后的字符串，利用map()函数，就可以输出新的list 。 参考代码: def format_name(s):

return s[0].upper() + s[1:].lower() print map(format name, ['adam', 'LISA', 'barT']) 2. reduce() 函数 def f(x, y): return x + y 调用reduce(f, [1, 3, 5, 7, 9]) 时，reduce 函数将做如下计算：先计算头两个元素：f(1, 3) ，结果为4； 再把结果和第3个元素计 算：f(4, 5) ，结果为9； 再把结果和第4 个元素计 算：f(9, 7) ，结果为16； 再把结果和第5 个元素计 算：f(16, 9) ，结果为 25； 由于没有更多的元素了，计算结束，返回结果25。 上述计算实际上是对list 的所有元素求和。虽然Python 内置了求和函数sum() ，但是，利用reduce() 求和也很简单。 reduce() 还可以接收第 3 个可选参数，作为计算的初始值。如果把初始值设为100，计算： reduce(f, [1, 3, 5, 7, 9], 100) 结果将变为125，因为第一轮计算是：计算初始值和第一个元素：f(100, 1) ，结果为101。 Python 内置了求和函数sum() ，但没有求积的函数，请利用recude() 来求积：输入：[2, 4, 5, 7, 12] 输出：2*4*5*7*12 的结果 reduce() 接收的函数 f 需要两个参数，并返回一个结果，以便继续进行下一轮计算。参考代码: def prod(x, y): return x * y print reduce(prod, [2, 4, 5, 7, 12]) 3. filter() 函数 filter() 函数是Python 内置的另一个有用的高阶函数，filter() 函数接收一个函数f 和一个list ，这个函数 f 的作用是对每个元素进行判断，返回True 或False ，filter() 根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list 。 例如，要从一个list [1, 4, 6, 7, 9, 12, 17] 中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：def is_odd(x): return x % 2 == 1 然后，利用filter() 过滤掉偶数：filter(is odd, [1, 4, 6, 7, 9, 12, 17]) 结果：[1, 7, 9, 17]

python一些常用方法

1.list 方法 一、创建一个列表 只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示： 复制代码代码如下: list1 = ['physics', 'chemistry', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"]; 与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。 二、访问列表中的值 使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示： 复制代码代码如下: #!/usr/bin/python list1 = ['physics', 'chemistry', 1997, 2000]; list2 = [1, 2, 3, 4, 5, 6, 7 ]; print "list1[0]: ", list1[0] print "list2[1:5]: ", list2[1:5] 以上实例输出结果： 复制代码代码如下: list1[0]: physics list2[1:5]: [2, 3, 4, 5] 三、更新列表 你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示： 复制代码代码如下: #!/usr/bin/python list = ['physics', 'chemistry', 1997, 2000]; print "Value available at index 2 : " print list[2]; list[2] = 2001; print "New value available at index 2 : " print list[2];

python中常用的模块的总结

a.定义： 模块用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），本质就是.py 结尾的python文件。（例如：文件名：,对应的模块名：test） 包：用来从逻辑上组织模块的，本质就是一个目录（必须带有一个的文件） b．导入方法 import module_name import module_1的本质：是将module_1解释了一遍 也就是将module_1中的所有代码复制给了module_1 from module_name1 import name 本质是将module_name1中的name变量放到当前程序中运行一遍 所以调用的时候直接print(name)就可以打印出name变量的值 代码例子：自己写的模块，其他程序调用，如下所示: 模块代码： 复制代码 1 name = "dean" 2 def say_hello(): 3 print("hello %s" %name) 调用模块的python程序main代码如下：（切记调用模块的时候只需要import模块名不需要加.py） import module_1 #调用变量 print #调用模块中的方法

() 复制代码 这样运行main程序后的结果如下： 1 D:\python35\ D:/python培训/s14/day5/module_test/ 2 dean 3 hello dean 4 5 Process finished with exit code 0 import module_name1,module_name2 from module_name import *(这种方法不建议使用) from module_name import logger as log(别名的方法) c.导入模块的本质就是把python文件解释一遍 import module_name---->>的路径----> 导入包的本质就是执行该包下面的 关于导入包的一个代码例子： 新建一个package_test包，并在该包下面建立一个的python程序，在package包的同级目录建立一个的程序 test1的代码如下： 1 def test(): 2 print("int the test1") package_test包下的的代码如下： 1 #import test1 （理论上这样就可以但是在pycharm下测试必须用下面from .import test1） 2 from . import test1 3 print("in the init") p_test的代码如下： 1 import package_test #执行 2 这样运行p_test的结果：