# lwf

**Repository Path**: li-weifeng777/python

## Basic Information

- **Project Name**: lwf
- **Description**: No description available
- **Primary Language**: Python
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-12-08
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# python

#函数的参数
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(4,3))

#字符编码
#python字符串支持多语言
print('支持多语言的str')

#ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符
a=ord('A')
print(a)
b=ord('中')
print(b)
a=chr(66)
print(a)
b=chr(25991)
print(b)

#如果知道字符的整数编码，还可以用十六进制写
print('\u4e2d\u6587')

#由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
#要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
#以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
a='ABC'.encode('ascii')
print(a)

b='中文'.encode('utf-8')
print(b)

#反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：
a=b'ABC'.decode('ascii')
print(a)

b=b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
print(b)

#如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：
b=b'\xe4\xb8\xad\xe6\x96'.decode('utf-8',errors='ignore')
print(b)

#len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：
a=len('ABC')
print(a)

b=len(b'ABC')
print(b)

#%运算符就是用来格式化字符串的
#%d	整数
#%f	浮点数
#%s	字符串
#%x	十六进制整数
print('Hello, %s' % 'world')
print('Hi, %s, you have $%d.' % ('Michael', 1000000))
#其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
print('%2d-%04d' % (3, 1))
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)

#如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：
print('Age: %s. Gender: %s' % (25, True))
#这个时候就需要转义，用%%来表示一个%：
print('growth rate: %d %%' % 7)

#format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，
print('Age:{0},Gender:{1}'.format(15,'男'))

#f-string，它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换：
a=123
b=456*a
print(f'Age is {a},py={b:.2f}')


#小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出'xx.x%'，只保留小数点后1位：
s1 = 72
s2 = 85
r = (s2/s1-1)*100
print('小明的百分点为:%.1f%%' % r)
print('小明的百分点为:{0:.1f}%'.format(r))
print(f'小明的百分点为:{r:.1f}%')

#转义字符
#输出I'm "OK"

print('I\'m \"OK\"')
#\n换行 \t制表符 \\表示\ 

print('a\nb\nc\ne\tf\tg\t')
print('\\\n\\')

#r''默认''内部不转义
print(r'\\\n\\')

#'''...'''表示多行内容
print('''a
b
c''')

#r'''...'''内部不转义
print(r'''a
b\nc''')

#布尔值，与或否运算
# True and False
# True or False
# 5>3
# not True

#变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言
a=123
print(a)
a='ABC'
print(a)

#/为除法，//为取整，%为取余
a=10
print(a/3)
print(a//3)
print(a%3)

#练习
n=123
print('n =',n)
f=456.789
print('f =',f)
print('\'Hello,world\'')
print('\'Hello,\\\'Adam\\\'\'')
print('r\'Hello,\"Bart\"\'')
print('''r\'\'\'Hello,
Lisa!\'\'\'''')

#list 和 tuple
#list
classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)

print(classmates[0])
print(classmates[-1])

#追加元素
classmates.append('Adam')
print(classmates)

#插入元素
classmates.insert(1, 'L')
print(classmates)

#删除末尾元素
classmates.pop()

#访问限制
class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))
    
    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def set_score(self, score):
        self.__score = score

bart = Student('Bart Simpson', 59)
print(bart.get_score())


#继承和多态
class Animal(object):
    def run(self):
        print('Animal is running...')
class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Eating meat...')

class Cat(Animal):
    pass
def run_twice(animal):
    animal.run()
    animal.run()


dog = Dog()
dog.run()

cat = Cat()
cat.run()

run_twice(Animal())
run_twice(Dog())

#类的属性和实例的属性
class Student(object):
    name = 'Student'
s = Student()
print(s.name)
print(Student.name)

s.name = 'Michael' # 给实例绑定name属性
print(s.name)
print(Student.name)
del s.name
print(s.name)# 删除实例的name属性

#练习
class Student(object):
    count = 0
    def __init__(self, name):
        self.name = name
        Student.count = Student.count + 1


#Test
class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))
    
    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

    def set_score(self, score):
        self.__score = score

bart = Student('Bart Simpson', 59)
print(bart.get_score())


class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

class Student(object):

    count = 0

    def __init__(self, name):

        self.name = name

        Student.count = Student.count + 1

class Screen(object):
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self, value):
        self._width = value
    @property
    def height(self):
        return self._height
    @height.setter
    def height(self, value):
        self._height = value
    @property
    def resolution(self):
        return self._width * self._height


class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        if self.score >= 80:
            if self.score > 100:
                raise ValueError('不可能超过100！')
            else:
                return 'A'        
        elif self.score >= 60:
            return 'B'
        else:
            if self.score < 0:
                raise ValueError('不可能是负数！')
            else:
                return 'C'