标签：__ name Python age Days master print self def

python100day学习第二周

# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
list1 = [1, 3, 5, 7, 100]
for index, elem in enumerate(list1):
    print(index, elem)

文件后缀名

#返回一个文件的后缀名
def getSuffix(filename):
    suffix = filename.rfind('.')
    return filename[suffix+1:]
print(getSuffix("hello.txt"))

返回列表中最大和第二大的值

# 返回列表中最大和第二大的值
def max12(listname):
    max1 = max(listname)
    newlist = listname.remove(max1)
    max2 = max(listname)
    return max1,max2
result = max12([1,2,3,5,4])
print(result)

约瑟夫问题

# 约瑟夫环问题
# 30个数，开始循环，如果到9，则标记为0
def yuesefu():
    persons = [1]*30
    total_sum = 0
    loc = 0
    num = 0
    while total_sum < 15:
        if persons[loc]:
            num += 1
            if num == 9:
                total_sum += 1
                persons[loc] = 0
                num = 0
        loc += 1
        loc %= 30
    return persons

print(yuesefu())

python的==和is有区别，is比较两个对象的id，==比较值是否相等

def main():
    x = y = -1
    while True:
        x += 1
        y += 1
        if x is y:
            print('%d is %d' % (x, y))
        else:
            print('Attention! %d is not %d' % (x, y))
            break

    x = y = 0
    while True:
        x -= 1
        y -= 1
        if x is y:
            print('%d is %d' % (x, y))
        else:
            print('Attention! %d is not %d' % (x, y))
            break


if __name__ == '__main__':
    main()

Python把一些频繁使用的整数对象缓存起来，保存到一个叫small_ints的链表中，在Python的整个生命周期内，任何需要引用这些整数对象的地方，都不再重新创建新的对象，而是直接引用缓存中的对象。Python把频繁使用的整数对象的值定在[-5, 256]这个区间，如果需要这个范围的整数，就直接从small_ints中获取引用而不是临时创建新的对象。因为大于256或小于-5的整数不在该范围之内，所以就算两个整数的值是一样，但它们是不同的对象

但是如果在同一模块中，那么是地址相同

a = 257


def main():
    b = 257  # 第6行
    c = 257  # 第7行
    print(b is c)  # True
    print(a is b)  # False
    print(a is c)  # False


if __name__ == "__main__":
    main()

python的下划线小结

1. python的单下划线

   1. 如果是交互式情况下，单下划线表示上一条语句的输出结果

      >>> "python"
      'python'
      >>> _
      'python'
      >>> 
      

   2. 作为临时变量，在for循环中充当i

      for _ in range(5):
          print(_)
      

   3. 名称前加单下划线表示私有(末尾加双下划线没什么影响)，不强制，仅作为提示

      # 前置单下划线对于类调用影响不大
      # 但是如果是导包，则需在__all__中声明才可以调用
      class Student():
          def __init__(self,name,age):
              self._name = name
              self.age = age
              
      stu1 = Student("lp",18)
      print(stu1._name)
      print(stu1.age)
      

2. 双下划线

   1. 前置双下划线

      # 前置双下滑线才算比较好的设置保护
      # 这时候需要._类名__属性名才能进行调用
      class Student():
          def __init__(self,name,age):
              self.__name = name
              self.age = age
              
      stu1 = Student("lp",18)
      print(stu1._Student__name)
      print(stu1.age)
      

   2. 首尾双下划线(好像没见到过尾部双下划线的)

      一般是作为固定搭配__init__之类的

continue和pass的区别

a = 'python'
i = 2
for element in a:
    if element == 'y':
        pass
        i = 3
    else:
        print(element+str(i))

"""
p2
t3
h3
o3
n3
"""        

a = 'python'
i = 2
for element in a:
    if element == 'y':
        continue
        i = 3
    else:
        print(element+str(i))

"""
p2
t2
h2
o2
n2
"""

在打开的文件中，首先最好使用with open("xxx.xx") as xxxx:这样的形式

然后对于read()和readline()，产生的是str，如果是readlines，则产生的是list

这里在同目录下创建test.txt，里面的内容为

# test.txt
1212121
	21131241422141
	2144121331
	2131313123123

这里分别用不同的方法查看输出

with open("./test.txt") as fobj:
    print(fobj)
    print(type(fobj))
    for line in fobj:
        print(line)

with open("./test.txt") as fobj:
    contents = fobj.read()
    print("contents:",contents)
    print("**********************")
    print("type(contents):",type(contents))
    print("**********************")
    for line in fobj:
        print(line)

这里你可能会奇怪我为什么这样输出，这是因为下面的print(line)不输出了

with open("./test.txt") as fobj:
    contents = fobj.read()
    print("contents:",contents)
    print("type(contents):",type(contents))

with open("./test.txt") as fobj:
    contents = fobj.readlines()
    print("contents:",contents)
    print("type(contents):",type(contents))
    for line in contents:
        print(line)

继续回到前置单下划线，如果此时想设置成私有的，那么可以使用getter和setter方法

getter和setter方法

class Person(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    # 访问器 - getter方法
    @property
    def name(self):
        return self._name

    # 访问器 - getter方法
    @property
    def age(self):
        return self._age

    # 修改器 - setter方法
    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳'  # AttributeError: can't set attribute


if __name__ == '__main__':
    main()

其实觉得这个getter和setter方法还是没什么用，因为还是可以用._的方法来调用

但是后面自己再去实现了一下前置双下划线，发现还是很有用的

class Person():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    @property
    def name(self):
        return self.__name
    
person = Person("xxx",18)
person.name

请注意，下面我刻意把name打成了nam，调用的时候也必须使用.nam

class Person():
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    @property
    def nam(self):
        return self.__name
    @nam.setter
    def nam(self,nam):
        self.__name = nam
        
person = Person("xxx",18)
person.nam

@property装饰器的作用：既要保护类的封装特性，又要让开发者可以使用“对象.属性”的方式操作操作类属性

注意，不加@property不会变成getter方法，输出只会是类中的一个方法

可以查看下面两种输出

使用return方法：

class Person():
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    def name(self):
        return self.__name
    def age(self):
        return self.age
    
person = Person("xxx",18)
print(person.name)
print(person.age)

<bound method Person.name of <__main__.Person object at 0x000001B47B0E61F0>>
18

使用print方法

class Person():
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    def name(self):
        print(self.__name)
    def age(self):
        print(self.age)
    
person = Person("xxx",18)
print(person.name)
print(type(person.name))
print(person.age)
print(type(person.age))
# 这里age会自动识别成属性，而不是方法
person.age("hello")
person.age()

在上面的例子中，我们知道如果属性和方法重名，会自动识别为属性，不会像Java一样，当然我们一般也不会这样做，再看下面这两个例子会更清楚地理解为什么会有@property地getter方法，以及@修饰属性.setter方法，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改。

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def name(self):
        print(self.name+"hello")
        
stu = Student("xxx",18)
print(stu.name)
stu.name()

class Student():
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    def name(self):
        print(self.name+"hello")

stu = Student("xxx",18)
print(stu.name)

学到这里，那同样把property函数也学习了一下

property(fget=None, fset=None, fdel=None, doc=None) -> property attribute

直接看例子

class Student:
    def __init__(self):
        self._age = None

    def get_age(self):
        print('获取属性时执行的代码')
        return self._age

    def set_age(self, age):
        print('设置属性时执行的代码')
        self._age = age

    def del_age(self):
        print('删除属性时执行的代码')
        del self._age

    age = property(get_age, set_age, del_age, '学生年龄')


student = Student()
# 注意要用 类名.属性.__doc__ 的形式查看属性的文档字符串
print('查看属性的文档字符串：' + Student.age.__doc__)
"""
查看属性的文档字符串：学生年龄
"""

# 设置属性
student.age = 18
"""
设置属性时执行的代码
"""

# 获取属性
print('学生年龄为：' + str(student.age))
"""
获取属性时执行的代码
学生年龄为：18
"""

# 删除属性
del student.age
"""
删除属性时执行的代码
"""

上例中，可一步一步调试，最后del student.age，再查看student.age

静态方法暂时还是没感觉有什么用，比如下例可以直接调用

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
Student('xxx',18).name

除了静态类，还可以在类中指定一个类方法为类

听起来很绕，实际上就是在已有的类中，新建一个方法，但这个方法是被@classmethod修饰的，并且返回一个类，看下例(嗯，下例是py2.7，为此尝试anaconda安装py2.7并尝试用conda install nb_conda_kernels这样的方法安装jupyter，虽然有py2.7的这个kernel，但是无法打开，所以最后使用了conda create -n py27 python=2.7 ipykernel语句来添加py2.7)

class Data_test2(object):
    day=0
    month=0
    year=0
    def __init__(self,year=0,month=0,day=0):
        self.day=day
        self.month=month
        self.year=year

    @classmethod
    def get_date(cls, string_date):
        #这里第一个参数是cls， 表示调用当前的类名
        year,month,day=map(int,string_date.split('-'))
        date1=cls(year,month,day)
        #返回的是一个初始化后的类
        return date1

    def out_date(self):
        print "year :"
        print self.year
        print "month :"
        print self.month
        print "day :"
        print self.day
        
r=Data_test2.get_date("2016-8-1")
r.out_date()


"""
year :
2016
month :
8
day :
1
"""

python没有真正的抽象类，也可以使用abc来达到抽象类的效果

标签：__,name,Python,age,Days,master,print,self,def
来源： https://www.cnblogs.com/lpzju/p/15616463.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。