python新手菜鸟之基础篇

s=0
for i in range(1,101):
    s += i
else:
    print(s)
def main(n):
    '''打印菱形图形'''
    for i in range(n):
        print((' * '*i).center(n*3))
    for i in range(n,0,-1):
        print((' * '*i).center(n*3))
main(6)
#计算理财产品收益
def licai(base,rate,days):
    result = base
    times = 365//days
    for i in range(times):
        result = result+result*rate/365*days #假设本金与利息一起滚动
    return result
print(licai(100000,0.0543,90))

#多次调用同一函数而产生的bug
def demo(newiten,old_list=[]):
    '''如果增加一个判断返回值初始化为默认值时，就不会产生bug
    如：if old_list is None: old_list=[]'''
    old_list.append(newiten)
    return old_list
print(demo('',['','','']))
print(demo('aaa',['a','b']))
#在多次调用函数并不为默认值参数传递值时，默认值参数只
# 在第一次调用时进行解释，这样会导致bug
print(demo('a'))
print(demo('g'))

#计算圆的面积
from math import pi as PI
def CircleArea(r):
    if isinstance(r,(int,float)):
        return PI * r**2
    else:
        print('Error')
print(CircleArea(3))
#使用lambda表达式，注意其变量的作用域
r=[]
for x in range(10):
    r.append(lambda n=x:n**2)#不能直接引用x值，lambda表达式中使用局部变量
print(r[5]())
#类对象的定义
class A:
    def __init__(self,value1=0,value2=0):
        self._value1 = value1
        self.__value2 = value2
    def show(self):
        print(self._value1)
        print(self.__value2)
a = A()
print(a._value1)
print(a._A__value2)
#数据成员定义
class Demo(object):
    total = 0
    def __new__(cls, *args, **kwargs):#该方法在__init__()之前被调用
        if cls.total >= 3:
            raise Exception("最多只能创建3个对象")
        else:
            print('实例化',Demo.total)
            return object.__new__(cls)
    def __init__(self):
        Demo.total = Demo.total + 1
t1 = Demo()
#方法
class Root:
    __total =0
    def __init__(self,v):
        self.___value=v
        Root.__total +=1
    def show(self):
        print('Self:',self.___value)
        print('Root:',Root.__total)
    @classmethod
    def classShowTotal(cls):
        '''类方法，只能访问类成员'''
        print(cls.__total)
    @staticmethod
    def staticShowTotal():
        '''静态方法，也是只能访问类成员'''
        print(Root.__total)
r = Root(3)
Root.classShowTotal()
Root.staticShowTotal()
r.show()
#属性
class Test1:
    def __init__(self,value):
        self.__value = value
    @property          #修饰器属性，只读，无法修改和删除
    def value(self):
        return self.__value
class Test2:
    def __init__(self,value):
        self.__value = value
    def __getValue(self):
        return self.__value
    def __setValue(self,v):
        self.__value = v
    value = property(__getValue,__setValue)#设置属性可读可写操作
#继承
class Person:
    def __init__(self):
        print('this is a parent class')
    def setName(self,name):
        if not isinstance(name,str):
            print('name must be string.')
            self.__name = ''
            return
        self.__name = name
        print(self.__name)
#派生类
class Teacher(Person):
    def __init__(self):
        super(Teacher,self).__init__()#也可以直接用Persion.__init__()

    def setDepartment(self,department):
        #if type(department) != str:
        if not isinstance(department,str):
            print('department must be string.')
            self.__department = 'Computer'
            return
        self.__department = department
if __name__ == '__main__':
    zhangsan = Teacher()
    zhangsan.setName('Lisi')
'''探讨继承中的问题，到底基类是否要继承object呢'''
class A:
    def foo(self):
        print('called A.foo()')
class B(A):
    pass
class C(A):
    def foo(self):
        print('called C.foo()')
class D(B,C):
    pass
d = D()
d.foo()#A类继承object，或不继承object结果会是什么呢？（答案：called C.foo()）
'''分析：如果A类是经典类（不继承object），当调用D的实例的foo()方法时，Python
会按照深度优先的方法搜索foo(),路径B-A-C,执行A中的foo();如果A是新式类（继承object），
则会按照广度优先的方法去搜索foo(),路径B-C-A,执行C中的foo();
   通过以上分析：其实新式类更符合逻辑；通常对应Python3.x中的新式类已经兼容了经典类，即无论A是否
继承object类，D中都会执行C中的foo()方法，但是在Python2.7-3.0中仍然存在上述的差异，所以我们推荐使用新
式类，要继承object类'''
#类的继承机制
class A(object):
    def __init__(self):
        self.__private()
        self.public()

    def __private(self):#基类的私有成员方法
        print('__private Method of A1')
    def public(self):
        print('public Method of A2')
class B(A):
    #没有构造函数，在创建实例时，直接走基类构造函数，对于重写
    # 非私有成员方法后，此时在基类调用的方法为派生类中的
    #如果有构造函数，实例化时则直接是走派生类中的构造函数
    def __private(self):
        print('Method of B1')
    def public(self):
        print("public Method of B2")
b = B()
b.public()

#字符串
#1.短字符串驻留机制，共享同一个副本值
a=''
b=''
print(id(a) == id(b),b)
#2.格式化模板类
from string import Template
t = Template('My name is ${name},and is ${age} years old')
d ={'name':'dong','age':34}
print(t.substitute(d))
#3.字符串常用方法find(),rfind(),index(),rindex(),count()
'''find():查找字符串首次出现的位置
   rfind():查找字符串最后出现的位置
   index():查找字符串首次出现的位置'''
s = 'apple,peach,banana,peach,pear'
print(s.find('pp'))
print(s.index('pp'))
#4.split(),rsplit(),partition(),rpartition()
'''split(),rsplit()返回的是列表,如果有多个连线空白字符在未指定分隔符情况下，默认作为一个
   partition(),rpartition()返回的是元组'''
li = s.split(',')
print(li)
print(s.partition(',,'))#分隔成3部分，如果原字符串中不包含分隔符，则返回原字符串及两个空字符串
ss='2014-10-20'
print(list(map(int,ss.split('-'))))#map对数据进行类型转换
#5.join()将列表中的多个字符串连接起来，并插入指定字符
lst = ['say','hello','miao','bai']
print("-".join(lst))
#使用split()与join()方法可以巧妙删除字符串中多余的空字符，并保留一个
#6.lower(),upper(),capitalize(),title(),swapcase()
'''lower():返回小写字符串；upp():返回大写字符串：capitalize():返回字符串首字符大写；
   title():每个单词首字母大写；swapcase():大小写互换；
   注意：这几个方法都是返回新字符串，对原字符串不做任何修改'''
#7.replace() 替换，也是返回新字符串
print('dfjgdifezadewwsaza'.replace('zad','ZAD'))
#8.maketrans(),translate()方法生成字符映射表和按映射表转换字符串并替换成字符，该方法可用来对字符串进行加密
#demo:创建映射表，将字符"abcdef123"一一对应转换成'uvwxyz@#$'
table =''.maketrans('abcdef123','uvwxyz@#$')
s ='Python is a greate programming language,I like it!'
print(s.translate(table))#按照映射表进行转换，使用方法可以实现恺撒加密算法
#9.对不可变对象字符串进行修改，需使用io.StringIO或array模块
#10.strip(),rstrip(),lstrip()分别用来删除两端、右端或左端连续的空字符串或指定字符串
'''这三个方法是对原字符串进行修改的'''
print('aaasdffffsfafaaaa'.rstrip('a'))
print('aaasdffaffsfafaaaa'.rstrip('af'))#注意：字符串中的af有不再两侧的，所以不删除
#11.eval()对字符串转换成Python表达式求值
print(eval('2+3'))
print(eval('[2,3,4,5]'))#注意：这里不能使用list(x)进行转换
#12.in、sartswith、endswith方法可用判断是否存在或以指定字符串开始或结束
#demo:startswith、endswith可以接受一个元组，如判断文件扩展名：
import os
[print(filename) for filename in os.listdir(r'F:\\') if filename.endswith(('.txt','.jpg','.gif'))]
#13.center()、ljust()、rjust()、zfill()返回指定宽度的新字符串，原字符串居中、左对齐、右对齐、左侧以字符0填充
print('hello world'.center(20,'-'))
print('uoi'.zfill(20))
#13.切片--读取字符串元素，不支持修改字符串
conent = 'Hello World!'
print(conent[:7])
#案例精选
#1.编写函数实现字符串加密和解密，循环使用指定密钥，采用简单的异或算法
def crypt(source,key):
    from itertools import cycle
    result=''
    temp = cycle(key)
    for ch in source:
        result = result + chr(ord(ch)^ord(next(temp)))
    return result
source ='ShangDong insitite of business and technology'
key ='Dong Fuguo'

print('Before source:'+source)
encryt = crypt(source,key)
print('After encryt:'+encryt)
decryt = crypt(encryt,key)
print('After decryt:'+decryt)

import itertools
'''chain:连接两个列表进行迭代
   count:从指定值开始，进入一个无界循环中
   cycle:生成无界迭代器
   filterfalse:返回一个可以使fun返回False的迭代器(python3.x中没有ifilter)
   islice:返回一个迭代器，并指定start开始，stop结束，step步长
   zip_longest:返回迭代器，并将列表进行组合，生成元组
   repeate:将对应列表按重复生成n次'''
listone=['a','b','c']
listtwo=['11','22','33']
# for item in itertools.chain(listone,listtwo):
#     print(item)
# for item in itertools.count(10):
#     print(item)
# for item in itertools.cycle(listone):
#     print(item)#无线循环
def funLargeFive(x):
    if x > 5:
        return True
# for item in itertools.filterfalse(funLargeFive,range(-10,10)):
#     print(item)
listthree =[1,2,3]
def funAdd(x):
    return x+5
for item in itertools.islice(listthree,1,2):
    print(item)
for item in itertools.zip_longest(listone,listthree):
    print(item)
stringBase='\u7684\u4e86\u662f'
print(''.join(stringBase.split('\\u')))
#目录树
import os
list_way = (list(os.walk(r".")))#产生一个三元tupple(dirpath[起始路径],dirnames[起始路径下的文件夹],filenames[起始路径下的文件名])
# for root,dirs,files in os.walk(r'F:\UpSVNProject\DownSVNProject\YzDEC',True):
#     print('root:%s'%root)
#     print('dirs:%s' % dirs)
#     print('files:%s' % files)
dict_way = dict( zip( [ i[0] for i in list_way] , list_way ) )
print(dict_way)
def to_txt(way):
    l = [ ]
    three = dict_way[ way ]
    print("==",three)
    tab_num = way.count("\\")
    if tab_num:
        l.append("\t" * (tab_num - 1)+way.split("\\")[ -1 ] + "\n" )
    for i in three[1]:
        l = l + to_txt( way+"\\"+i )
    for i in three[2]:
        l.append( "\t" * tab_num + i +"\n")
    return l
list_txt = to_txt(".")
print(list_txt)
with open("目录树.txt","w") as fil:
    for i in list_txt:
        fil.write(i)
#os.system('notepad 目录树.txt')
#正则表达式
import re
text ='apleld.be3ate...ganem..dadein'
print(re.split('[\.]+',text,maxsplit=2))#匹配分隔符.一次或多次，maxsplit最多分隔两次
print(re.findall('[a-zA-Z]+',text))#查找所有a-zA-Z的字符，以不是匹配的字符进行分隔
pat='name'
strs='Dear name..namelisty.'
print(re.sub(pat,'Mr.dong',strs))#匹配字符并替换指定的字符
example='shangdong institute of Business and technology is a very beautitful school'
print(re.findall('\\ba.+?\\b',example))#采用非贪婪模式
#使用re.compile()获取正则表达式对象，然后在使用其方法
pattern = re.compile(r'\bi\w+\b')
print(pattern.findall(example))
example1='ControlVolumne[0]'
import random
print(re.sub('(?<=\\[).+?(?=])',str(random.choice(range(100))),example1))
#match对象
email='tony@tiremove_thisger.net'
m = re.search('remove_this',email)
print(email[:m.start()],email[m.end():],m.group(0))
#子模式扩展语法
mm = re.match(r'(?P<first_name>\w+) (?P<last_name>\w+)','Malcolm Reynolds')
print(mm.group('first_name'))#命名的子模式
print(mm.groupdict())
mmm = re.match('(\d+)\.(\d+)','24.1632')
print(mmm.groups())
# s= 'aabc adcd abbcd abccd abcdd'
# p = re.compile(r'(\b\w* (?P<f>\w+) (?P=f)\w*\b)')
# print(p.findall(s))
#案例精选
#1.提取字符串中的电话号码
pattern = re.compile(r'(\d{3,4}-(\d{7,8}))')
print(pattern)
#json使用
import json
x=[1,31,4]
jx = json.dumps(x)
print(jx)#编码
print(json.loads(jx))#解码
#文件操作
'''需求：copy文件，并在新文件中行尾增加行号'''
filename =r'c:\Users\PGIDYSQ\Desktop\1111111e.gen'
with open(filename,'r') as fp:
    lines = fp.readlines()                                #读取所有行
maxLength = max(map(len,lines))                           #最长行的长度

for index ,line in enumerate(lines):                      #遍历所有行
    newLine = line.rstrip()                           #清理行右侧的空白字符
    newLine = newLine + ' '*(maxLength + 5 - len(newLine))
    newLine = newLine + "#" +str(index + 1) + '\n'          #添加行号
    lines[index] = newLine

with open(filename[:filename.rfind('\\')+1] +'_new.gen','w') as fp:
    fp.writelines(lines)
    print(fp.name)

以上内容由本人学习中所记录的，有点乱，~~共勉