python

print(True and False)
print(True or False)
print(not False)

def flexble(*num):
	sum=0
	for i in num:
		sum=sum+i*i
	return sum

print(flexble(1,2,3,4,5))


for i,v in enumerate(range(10)):
	print(i,v)


generator列表生成式
g=(x*x for x in range(10))
print(g)
for i in g:
	print(i)


迭代器

from PIL import Image

img=Image.open('330.jpg')
print(img.format,img.size,img.mode)
print(img._getexif())


import sys

for i in sys.path:
	print(i)


from datetime import datetime
print(datetime.now())



import requests
from bs4 import BeautifulSoup

html=requests.get('http://cuiqingcai.com/1319.html').text

soup=BeautifulSoup(html)
print('\n'*3)


# print(soup.title)
print(soup.p,'\n')
print(soup.p.string,'\n')
print(type(soup.p))
print(soup.prettify())
# print(soup.contents)

#!/user/bin/env python3
# -*- coding:utf-8 -*-

'main'
__author__='Qton'

# 面向物件程式設計
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))
		
qton=Student('qton',80)
qton.print_score()



# 類和例項
class Kechen(object):

	# 繫結屬性
	def __init__(self,ke,score):
		self.ke=ke
		self.score=score

	# 資料封裝
	def print_ke(self):
		print(self.ke)
	def print_score(self):
		print(self.score)

# 建立例項
english=Kechen('english',80)

# 列印例項
# print(english.ke)
english.print_score()





# 訪問限制
class Student(object):
	def __init__(self, name,score):

		# self.__name則只允許class內部訪問 private
		self.__name=name

		# self.score 則外部也可以訪問 public
		self.score=score

	# 內部訪問self.__name
	def print_name(self):
		print(self.__name)

# qton=Student('qton',80)
# qton.print_name()

# # 外部訪問
# print(qton.score)







# 繼承和多型

# 繼承
# Dog 類繼承上面 Student 類
class Dog(Student):
	pass

dog=Dog('dog',90)
dog.print_name()


# 多型 
# 當子類和父類都存在相同的run()方法時，我們說，子類的run()覆蓋了父類的run()

!/usr/bin/env python3
-*- coding: utf-8 -*-

class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')

class Cat(Animal):
    def run(self):
        print('Cat is running...')

def run_twice(animal):
    animal.run()
    animal.run()


a = Animal()
d = Dog()
c = Cat()


run_twice(c)
    # 輸出
 	# Cat is running...
	# Cat is running...



print('a is Animal?', isinstance(a, Animal))
print('a is Dog?', isinstance(a, Dog))
print('a is Cat?', isinstance(a, Cat))

print('d is Animal?', isinstance(d, Animal))
print('d is Dog?', isinstance(d, Dog))
print('d is Cat?', isinstance(d, Cat))


# 輸出
# a is Animal? True
# a is Dog? False
# a is Cat? False
# d is Animal? True
# d is Dog? True
# d is Cat? False
# Cat is running...
# Cat is running...




# 例項屬性和類屬性
class Student(object):
	name = 'Student'

s = Student() # 建立例項s

print(s.name) # 列印name屬性，因為例項並沒有name屬性，所以會繼續查詢class的name屬性
# Student

print(Student.name) # 列印類的name屬性
# Student

s.name = 'Michael' # 給例項繫結name屬性
print(s.name) # 由於例項屬性優先順序比類屬性高，因此，它會遮蔽掉類的name屬性
# Michael

print(Student.name) # 但是類屬性並未消失，用Student.name仍然可以訪問
# Student





# 面向物件高階程式設計
# 資料封裝、繼承和多型只是面向物件程式設計中最基礎的3個概念。
# 在Python中，面向物件還有很多高階特性，允許我們寫出非常強大的功能。
# 我們會討論多重繼承、定製類、元類等概念。

# 使用__slots__

class Student(object):
	pass

s=Student()
s.name='Qton'

def set_age(self,age):
	self.age=age




# 函式的引數

# 預設引數
def power(x,y=2):
	print(x,y)

# 引數為tuple list\
numbers=[1,2,3,4,5]
def calc(*numbers):
	for i in numbers:
		print(i)
print(calc(numbers))

# 關鍵字引數
# 允許傳入0個或任意多個引數
def person(name,age,**kw):
	print('name:',name,'age:',age,'other:',kw)
print(person('qton',23,city='jieyan',education='university'))

# 可寫成
kw={'city':'jieyan','education':'university'}
print(person('qton',23,**kw))

# 限制輸入任意引數
def person(name,age,*,city,education):
	print(name,age,city,education)
print(person('qton',23,city='jieyan',education='university'))
# person('qton',23,sex='boy') #這樣則會出錯




# 遞迴函式 
def fact(n):   #累乘
	if n==1:
		return 1
	else:
		return n*fact(n-1)
print(fact(3))

# 缺點是遞迴次數過多會導致棧溢位
# 如fact(1000) 所以不建議用




# 高階特性


# 除錯
print() #簡單粗暴 缺點是最後還得刪掉
# 斷言
# 凡是用print()來輔助檢視的地方，都可以用斷言（assert）來替代
# 啟動Python直譯器時可以用-O引數來關閉assert：
# $ python3 -O err.py
assert()
# 把print()替換為logging是第3種方式，和assert比，logging不會丟擲錯誤，而且可以輸出到檔案：
logging()
# 比較好 斷點





# 單元測試
# 文件測試
!/usr/bin/env python3
-*- coding: utf-8 -*-

class Dict(dict):
    '''
    Simple dict but also support access as x.y style.
    >>> d1 = Dict()
    >>> d1['x'] = 100
    >>> d1.x
    100
    >>> d1.y = 200
    >>> d1['y']
    200
    >>> d2 = Dict(a=1, b=2, c='3')
    >>> d2.c
    '3'
    >>> d2['empty']
    Traceback (most recent call last):
        ...
    KeyError: 'empty'
    >>> d2.empty
    Traceback (most recent call last):
        ...
    AttributeError: 'Dict' object has no attribute 'empty'
    '''
    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

if __name__=='__main__':
    import doctest
    doctest.testmod()

# 看幫助文件
# import re
# print(help(re))