importdatetimeshijian=datetime.date.today().strftime("%y-%m-%d") # 不要用拼音ymdstr=datetime.date.today().strftime("%y-%m-%d") # 不要用缩略语，除非这些缩率语大家一眼能认出来，也不需要变量里面加类型。

importdatetimecurrent_date: str=datetime.date.today().strftime("%y-%m-%d")

defget_user_info(): passdefget_client_data(): passdefget_customer_record(): pass

defget_user_info(): passdefget_user_data(): passdefget_user_record(): pass

fromtypingimportUnion, DictclassRecord: passclassUser: info : str@propertydefdata(self) ->Dict[str, str]: return{} defget_record(self) ->Union[Record, None]: returnRecord()

importtime# What is the number 86400 for again?time.sleep(86400) #魔鬼数字

importtime# 将它变成常量，在模块的全局域声明.SECONDS_IN_A_DAY=60*60*24time.sleep(SECONDS_IN_A_DAY)

importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches=re.match(city_zip_code_regex, address) ifmatches: print(f"{matches[1]}: {matches[2]}")

importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches=re.match(city_zip_code_regex, address) ifmatches: city, zip_code=matches.groups() print(f"{city}: {zip_code}")

importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(?P<city>.+?)\s*(?P<zip_code>\d{5})?$"matches=re.match(city_zip_code_regex, address) ifmatches: print(f"{matches['city']}, {matches['zip_code']}")

seq= ("Austin", "New York", "San Francisco") foriteminseq: #do_stuff()#do_some_other_stuff()# Wait, what's `item` again?print(item)

locations= ("Austin", "New York", "San Francisco") forlocationinlocations: #do_stuff()#do_some_other_stuff()# ...print(location)

classCar: car_make: strcar_model: strcar_color: str

classCar: make: strmodel: strcolor: str

importhashlibdefcreate_micro_brewery(name): name="Hipster Brew Co."ifnameisNoneelsenameslug=hashlib.sha1(name.encode()).hexdigest() # etc.

importhashlibdefcreate_micro_brewery(name: str="Hipster Brew Co."): slug=hashlib.sha1(name.encode()).hexdigest() # etc.

defcreate_menu(title, body, button_text, cancellable): pass

classMenu: def__init__(self, config: dict): self.title=config["title"] self.body=config["body"] # ...menu=Menu({"title": "My Menu", "body": "Something about my menu", "button_text": "OK", "cancellable": False } )

classMenuConfig: """A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title: strbody: strbutton_text: strcancellable: bool=Falsedefcreate_menu(config: MenuConfig) ->None: title=config.titlebody=config.body# ...config=MenuConfig() config.title="My delicious menu"config.body="A description of the various items on the menu"config.button_text="Order now!"# The instance attribute overrides the default class attribute.config.cancellable=Truecreate_menu(config)

fromtypingimportNamedTupleclassMenuConfig(NamedTuple): """A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title: strbody: strbutton_text: strcancellable: bool=Falsedefcreate_menu(config: MenuConfig): title, body, button_text, cancellable=config# ...create_menu( MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!" ) )

fromdataclassesimportastuple, dataclass@dataclassclassMenuConfig: """A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title: strbody: strbutton_text: strcancellable: bool=Falsedefcreate_menu(config: MenuConfig): title, body, button_text, cancellable=astuple(config) # ...create_menu( MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!" ) )

fromtypingimportTypedDictclassMenuConfig(TypedDict): """A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title: strbody: strbutton_text: strcancellable: booldefcreate_menu(config: MenuConfig): title=config["title"] # ...create_menu( # You need to supply all the parametersMenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!", cancellable=True ) )

fromtypingimportListclassClient: active: booldefemail(client: Client) ->None: passdefemail_clients(clients: List[Client]) ->None: """Filter active clients and send them an email. """forclientinclients: ifclient.active: email(client)

fromtypingimportListclassClient: active: booldefemail(client: Client) ->None: passdefget_active_clients(clients: List[Client]) ->List[Client]: """Filter active clients. """return [clientforclientinclientsifclient.active] defemail_clients(clients: List[Client]) ->None: """Send an email to a given list of clients. """forclientinget_active_clients(clients): email(client)

fromtypingimportGenerator, IteratorclassClient: active: booldefemail(client: Client): passdefactive_clients(clients: Iterator[Client]) ->Generator[Client, None, None]: """Only active clients"""return (clientforclientinclientsifclient.active) defemail_client(clients: Iterator[Client]) ->None: """Send an email to a given list of clients. """forclientinactive_clients(clients): email(client)

classEmail: defhandle(self) ->None: passmessage=Email() # handle 到底是干啥用的?message.handle()

classEmail: defsend(self) ->None: """Send this message"""message=Email() message.send()

# type: ignoredefparse_better_js_alternative(code: str) ->None: regexes= [ # ... ] statements=code.split('\n') tokens= [] forregexinregexes: forstatementinstatements: passast= [] fortokenintokens: passfornodeinast: pass

fromtypingimportTuple, List, DictREGEXES: Tuple= ( # ... ) defparse_better_js_alternative(code: str) ->None: tokens: List=tokenize(code) syntax_tree: List=parse(tokens) fornodeinsyntax_tree: passdeftokenize(code: str) ->List: statements=code.split() tokens: List[Dict] = [] forregexinREGEXES: forstatementinstatements: passreturntokensdefparse(tokens: List) ->List: syntax_tree: List[Dict] = [] fortokenintokens: passreturnsyntax_tree

fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name: str, temp: bool) ->None: iftemp: (Path(gettempdir()) /name).touch() else: Path(name).touch()

fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name: str) ->None: Path(name).touch() defcreate_temp_file(name: str) ->None: (Path(gettempdir()) /name).touch()

# type: ignore# fullname 是这个模块里的全局变量，是 string 类型.fullname="Ryan McDermott"defsplit_into_first_and_last_name() ->None: # fullname 是定义在这个模块里的全局变量，下面这行代码会改变这个全局变量的状态# 并产生一个副作用。globalfullnamefullname=fullname.split() split_into_first_and_last_name() # 调用完这个函数后fullname的类型就变了 由string 变成了 List[str]。再调用这个函数就会报错# 'Incompatible types in assignment: # (expression has type "List[str]", variable has type "str")'print(fullname) # ["Ryan", "McDermott"]

fromtypingimportList, AnyStrdefsplit_into_first_and_last_name(name: AnyStr) ->List[AnyStr]: returnname.split() fullname="Ryan McDermott"name, surname=split_into_first_and_last_name(fullname) print(name, surname) # => Ryan McDermott

fromdataclassesimportdataclass@dataclassclassPerson: name: str@propertydefname_as_first_and_last(self) ->list: returnself.name.split() # 这个类的目的就是统一控制状态!person=Person("Ryan McDermott") print(person.name) # => "Ryan McDermott"print(person.name_as_first_and_last) # => ["Ryan", "McDermott"]

fromimportlibimportmetadataclassVersionCommentElement: """An element that renders an HTML comment with the program's version number """defget_version(self) ->str: """Get the package version"""returnmetadata.version("pip") defrender(self) ->None: print(f'<!-- Version: {self.get_version()} -->') VersionCommentElement().render()

fromimportlibimportmetadatadefget_version(pkg_name:str) ->str: """Retrieve the version of a given package"""returnmetadata.version(pkg_name) classVersionCommentElement: """An element that renders an HTML comment with the program's version number """def__init__(self, version: str): self.version=versiondefrender(self) ->None: print(f'<!-- Version: {self.version} -->') VersionCommentElement(get_version("pip")).render()

fromdataclassesimportdataclass@dataclassclassResponse: """An HTTP response"""status: intcontent_type: strbody: strclassView: """A simple view that returns plain text responses"""defget(self, request) ->Response: """Handle a GET request and return a message in the response"""returnResponse( status=200, content_type='text/plain', body="Welcome to my web site" ) classTemplateView(View): """A view that returns HTML responses based on a template file."""defget(self, request) ->Response: """Handle a GET request and return an HTML document in the response"""withopen("index.html") asfd: returnResponse( status=200, content_type='text/html', body=fd.read() )

fromdataclassesimportdataclass@dataclassclassResponse: """An HTTP response"""status: intcontent_type: strbody: strclassView: """A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self) ->str: """Render the message body of the response"""return"Welcome to my web site"defget(self, request) ->Response: """Handle a GET request and return a message in the response"""returnResponse( status=200, content_type=self.content_type, body=self.render_body() ) classTemplateView(View): """A view that returns HTML responses based on a template file."""content_type="text/html"template_file="index.html"defrender_body(self) ->str: """Render the message body as HTML"""withopen(self.template_file) asfd: returnfd.read() 

fromdataclassesimportdataclass, fieldfromtypingimportProtocol@dataclassclassResponse: """An HTTP response"""status: intcontent_type: strbody: strheaders: dict=field(default_factory=dict) classView: """A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self) ->str: """Render the message body of the response"""return"Welcome to my web site"defget(self, request) ->Response: """Handle a GET request and return a message in the response"""returnResponse( status=200, content_type=self.content_type, body=self.render_body() ) classTemplateRenderMixin: """A mixin class for views that render HTML documents using a template file Not to be used by itself! """template_file: str=""defrender_body(self) ->str: """Render the message body as HTML"""ifnotself.template_file: raiseValueError("The path to a template file must be given.") withopen(self.template_file) asfd: returnfd.read() classContentLengthMixin: """A mixin class for views that injects a Content-Length header in the response Not to be used by itself! """defget(self, request) ->Response: """Introspect and amend the response to inject the new header"""response=super().get(request) # type: ignoreresponse.headers['Content-Length'] =len(response.body) returnresponseclassTemplateView(TemplateRenderMixin, ContentLengthMixin, View): """A view that returns HTML responses based on a template file."""content_type="text/html"template_file="index.html"

fromdataclassesimportdataclass@dataclassclassResponse: """An HTTP response"""status: intcontent_type: strbody: strclassView: """A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self) ->str: """Render the message body of the response"""return"Welcome to my web site"defget(self, request) ->Response: """Handle a GET request and return a message in the response"""returnResponse( status=200, content_type=self.content_type, body=self.render_body() ) classTemplateView(View): """A view that returns HTML responses based on a template file."""content_type="text/html"defget(self, request, template_file: str) ->Response: # type: ignore"""Render the message body as HTML"""withopen(template_file) asfd: returnResponse( status=200, content_type=self.content_type, body=fd.read() ) defrender(view: View, request) ->Response: """Render a View"""returnview.get(request)

fromabcimportABCMeta, abstractmethod# Define the Abstract Class for a generic Greeter objectclassGreeter(metaclass=ABCMeta): """An object that can perform a greeting action."""@staticmethod@abstractmethoddefgreet(name: str) ->None: """Display a greeting for the user with the given name"""classFriendlyActor(Greeter): """An actor that greets the user with a friendly salutation"""@staticmethoddefgreet(name: str) ->None: """Greet a person by name"""print(f"Hello {name}!") defwelcome_user(user_name: str, actor: Greeter): """Welcome a user with a given name using the provided actor"""actor.greet(user_name) welcome_user("Barbara", FriendlyActor())

importabcclassPersistable(metaclass=abc.ABCMeta): """Serialize a file to data and back"""@property@abc.abstractmethoddefdata(self) ->bytes: """The raw data of the file"""@classmethod@abc.abstractmethoddefload(cls, name: str): """Load the file from disk"""@abc.abstractmethoddefsave(self) ->None: """Save the file to disk"""# 针对 PDF 文档 我们只需要实现`.load()` 方法，并给`data` 赋对应的值。classPDFDocument(Persistable): """A PDF document"""@propertydefdata(self) ->bytes: """The raw bytes of the PDF document""" ... # Code goes here - omitted for brevity@classmethoddefload(cls, name: str): """Load the file from the local filesystem""" ... # Code goes here - omitted for brevitydefview(request): """A web view that handles a GET request for a document"""requested_name=request.qs['name'] # We want to validate this!returnPDFDocument.load(requested_name).data

importabcclassDataCarrier(metaclass=abc.ABCMeta): """Carries a data payload"""@propertydefdata(self): ... classLoadable(DataCarrier): """Can load data from storage by name"""@classmethod@abc.abstractmethoddefload(cls, name: str): ... classSaveable(DataCarrier): """Can save data to storage"""@abc.abstractmethoddefsave(self) ->None: ... classPDFDocument(Loadable): """A PDF document"""@propertydefdata(self) ->bytes: """The raw bytes of the PDF document""" ... # Code goes here - omitted for brevity@classmethoddefload(cls, name: str): """Load the file from the local filesystem""" ... # Code goes here - omitted for brevitydefview(request): """A web view that handles a GET request for a document"""requested_name=request.qs['name'] # We want to validate this!returnPDFDocument.load(requested_name).data

importcsvfromioimportStringIOclassStreamingHttpResponse: """A streaming HTTP response""" ... # implementation code goes heredefsome_view(request): rows= ( ['First row', 'Foo', 'Bar', 'Baz'], ['Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"] ) # Define a generator to stream data directly to the clientdefstream(): buffer_=StringIO() writer=csv.writer(buffer_, delimiter=';', quotechar='"') forrowinrows: writer.writerow(row) buffer_.seek(0) data=buffer_.read() buffer_.seek(0) buffer_.truncate() yielddata# Create the streaming response object with the appropriate CSV header.response=StreamingHttpResponse(stream(), content_type='text/csv') response['Content-Disposition'] ='attachment; filename="somefilename.csv"'returnresponse

importcsvclassEcho: """An object that implements just the write method of the file-like interface. """defwrite(self, value): """Write the value by returning it, instead of storing in a buffer."""returnvaluedefsome_streaming_csv_view(request): """A view that streams a large CSV file."""rows= ( ['First row', 'Foo', 'Bar', 'Baz'], ['Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"] ) writer=csv.writer(Echo(), delimiter=';', quotechar='"') returnStreamingHttpResponse( (writer.writerow(row) forrowinrows), content_type="text/csv", headers={'Content-Disposition': 'attachment; filename="somefilename.csv"'}, )

fromtypingimportList, Dictfromdataclassesimportdataclass@dataclassclassDeveloper: def__init__(self, experience: float, github_link: str) ->None: self._experience=experienceself._github_link=github_link@propertydefexperience(self) ->float: returnself._experience@propertydefgithub_link(self) ->str: returnself._github_link@dataclassclassManager: def__init__(self, experience: float, github_link: str) ->None: self._experience=experienceself._github_link=github_link@propertydefexperience(self) ->float: returnself._experience@propertydefgithub_link(self) ->str: returnself._github_linkdefget_developer_list(developers: List[Developer]) ->List[Dict]: developers_list= [] fordeveloperindevelopers: developers_list.append({'experience' : developer.experience, 'github_link' : developer.github_link }) returndevelopers_listdefget_manager_list(managers: List[Manager]) ->List[Dict]: managers_list= [] formanagerinmanagers: managers_list.append({'experience' : manager.experience, 'github_link' : manager.github_link }) returnmanagers_list## create list objects of developerscompany_developers= [ Developer(experience=2.5, github_link='https://github.com/1'), Developer(experience=1.5, github_link='https://github.com/2') ] company_developers_list=get_developer_list(developers=company_developers) ## create list objects of managerscompany_managers= [ Manager(experience=4.5, github_link='https://github.com/3'), Manager(experience=5.7, github_link='https://github.com/4') ] company_managers_list=get_manager_list(managers=company_managers)

fromtypingimportList, Dictfromdataclassesimportdataclass@dataclassclassEmployee: def__init__(self, experience: float, github_link: str) ->None: self._experience=experienceself._github_link=github_link@propertydefexperience(self) ->float: returnself._experience@propertydefgithub_link(self) ->str: returnself._github_linkdefget_employee_list(employees: List[Employee]) ->List[Dict]: employees_list= [] foremployeeinemployees: employees_list.append({'experience' : employee.experience, 'github_link' : employee.github_link }) returnemployees_list## create list objects of developerscompany_developers= [ Employee(experience=2.5, github_link='https://github.com/1'), Employee(experience=1.5, github_link='https://github.com/2') ] company_developers_list=get_employee_list(employees=company_developers) ## create list objects of managerscompany_managers= [ Employee(experience=4.5, github_link='https://github.com/3'), Employee(experience=5.7, github_link='https://github.com/4') ] company_managers_list=get_employee_list(employees=company_managers)