def string_interpolation(): value1 = 1 value2 = 2 value3 = 3 # Noncompliant value4 = 4 # Noncompliant (previously FN) value5 = 1 foo(F'{value5} foo') value6 = '' # Noncompliant FP print(f"{'}' + value6}") return f'{value1}, {2*value2}, value3bis, value4'
def using_tuples(): x, y = (1, 2) print x (a, b) = (1, 2) print b for name, b in foo(): pass for (c, d) in foo(): pass
def string_interpolation(): value1 = 1 value2 = 2 value3 = 3 # Noncompliant value4 = 4 # Noncompliant value5 = 1 foo(F'{value5} foo') value6 = '' print(f"{'}' + value6}") value7 = '' printf(rf'{value7}') return f'{value1}, {2*value2}, value3bis, value4'
def string_interpolation(): value1 = 1 value2 = 2 value3 = 3 # Noncompliant value4 = 4 # Noncompliant value5 = 1 foo(F'{value5} foo') value6 = '' print(f"{'}' + value6}") value7 = '' printf(rf'{value7}') value8 = 10 value9 = 10 print(f"{3.14159265358979:{value8}.{value9 * 5}}") return f'{value1}, {2*value2}, value3bis, value4'
def test_override_builtin(self): # Test that overriding builtins.__import__ can bypass sys.modules. import os def foo(): import os return os self.assertEqual(foo(), os) # Quick sanity check. with swap_attr(builtins, "__import__", lambda *x: 5): self.assertEqual(foo(), 5) # Test what happens when we shadow __import__ in globals(); this # currently does not impact the import process, but if this changes, # other code will need to change, so keep this test as a tripwire. with swap_item(globals(), "__import__", lambda *x: 5): self.assertEqual(foo(), os)
# actually a new local! global_ = "local" # actually not a new local but imported one? imported = "imported" return local return param1 return imported def foo2(): global global_ # now it references the global global_ = "global2" return global_ def foo3(x, y): def bar(x): nonlocal y return x + y yield bar(x) print(foo.imported) print(global_) foo(1, 2) print(global_) foo2() print(global_)
def testCallFunc(self): foo(bar) foo(bar=None) foo(bar, moo=None) foo(boo, *args) foo(boo, *args, **kwargs)
def test(self): response = foo() self.assertEqual(200, response.status_code) self.assertEqual(b'Hello World', response.content)
def foo(x): print x print y # Sunaba と違ってグローバル変数を関数内で使ってもいい # --- リストも渡せる --- def sum_list(a): total = 0 for b in a: total += b return total print sum_list([1, 2, 3]) # 6 # --- デフォルト引数 --- def foo(a, b = 10, c = 'c'): print a, b, c foo(1) # 1, 10, c が出る # --- キーワード引数 --- def foo(a, b = 10, c = 'c'): print a, b, c foo(1, c = 'しい', b = 2) # 順番があべこべでもOK def bar(a, b = 10, **c): print a, b, c bar(1, b = 20, d = 20, e = 40) # {'d': 20, 'e': 40}ってのが出てくる # --- ディクショナリを展開して関数に渡す --- dic1 = {'a': 10, 'b': 20} def foo(a = 1, b = 2): print a, b print foo(**dic1) # 10, 20 が出てくる
#/usr/bin/python3 # #module print("=" * 100) print("6.1 Module") print("=" * 100) import foo foo.foo(200) print(foo.__name__) #import other way #or from foo import * will import all functions except the function which name start with _ #from foo import foo from foo import * foo(50) #can't access _xxx function #_test() #foo._test() #or rename from foo import foo as foo1 foo1('This is foo1') #if using interative mode, the module only import once, or use importlib.reload(modulename)。
ИМПОРТЫ СОРТИРУЮТСЯ ЛЕКСИКОГРАФИЧЕСКИ регистроЗАВИСИМО СОГЛАСНО ПОЛНОМУ ПУТИ МОДУЛЯ import foo from foo import bar from foo.bar import baz from foo.bar import Quux from Foob import ar КОНСТРУКЦИЯ НА ОДНОЙ СТРОКЕ ТОЛЬКО IF EXP НЕ СОСТАВНОЕ if foo: bar(foo) if foo: bar(foo) else: foo(bar) ?КОНТРОЛЬ ДОСТУПА #if геттер был бы простым, я должен был бы использовать общедоступные v для геттеров для избежания дополнительных расходов на внутренние вызовы p. if добавлено много фунциональности, можно исп св-ва, чтобы следовать целосности интерфейса. С одной стороны if геттер более сложна|скорость доступа к v важна -> можно использовать вызовы Fx(такие как get_foo(), set_foo()). If поведение позволяет доступ через св-во - не привязывай к нему новый геттер. Любой код, который все еще пытается получить доступ к v с помощью старого метода, должен явно падать чтобы я увидел что сложность доступа изменилась ИМЕНОВАНИЕ module_name, package_name ClassName method_name ExceptionName function_name GLOBAL_CONSTANT global_variable instance_var function_parameter
def test(self): response = foo() self.assertEqual(True, foo())
import requests x = requests.get('http://foo.com/users') x.json() #---------------------------------------- while x != 3: print(x) x = x + 1 #---------------------------------------- function def foo(x, y): print(x,y) return x foo(123) # calling the function #---------------------------------------- files x = open(foo.txt, 'w') # 'w' 'r' 'a' x.write('hello\n') x.write('brian\n') x.close() x = open('foo.txt', 'r') print(x.read()) # .readline() x.close() #---------------------------------------- x = [] x.append(1) x.append(2)
from foo import * import bar print('Вызываю foo(x) от 10') foo(10) print('Вызываю bar(x) от 100 = ' + str(bar.bar(100)))
## subn re.subn('a', 'b', 'c') re.subn('a', 'b', 'c', 0) re.subn('a', 'b', 'c', 0, re.IGNORECASE) re.subn('a', 'b', 'c', flags=re.IGNORECASE) re.subn('a', 'b', 'c', count=0, flags=re.IGNORECASE) ## escape re.escape('a') # Goofy verbose (X) example from python docs re.compile( r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) # Try with lots of flags re.compile('[a-z]+', re.IGNORECASE | re.MULTILINE) re.compile('[a-z]+', re.IGNORECASE | re.MULTILINE | re.DOTALL) # More complex calls ## Nesting -- should be <nestedOnce, 'DYNAMIC-FLAGS'> and <nestedTwice, ''> foo( re.match('nestedOnce', 'b', re.IGNORECASE if re.match('nestedTwice', 'd') else re.IGNORECASE)) ## Partially-dynamic flags re.compile('partiallyDynamicFlags-[a-z]+', re.IGNORECASE | foo(re.MULTILINE)) ## Numeric flags re.subn('a', 'b', flags=0) re.subn('a', 'b', flags=0 | re.IGNORECASE)
from foo import ( foo foo ) code = 1 from foo import ( foo foo foo ) code = 1 import foo; foo() import foo import foo import foo code = 1 from foo import \ bar code = 1 from foo import \ bar \ bar
def funcs(): foo(1) foo(1, 2) foo(1, 2, 3)
def bar(): if(1 == 2): return 0 if(1+2 == 1+2): return 1 if(1+2 == 1+2): foo() if(x == x): foo() bar() if(True) foo() foo() if(True) foo() foo()
#! coding: cp1252 import foo import bar foo(""" "Alors vous imaginez ma surprise, au lever du jour, quand " "une drôle de petite voix m’a réveillé. Elle disait: " "« S’il vous plaît… dessine-moi un mouton! »" """) bar()
def test_something(self): # print(type(self)) self.assertEqual(True, False) foo() # understading __name__ == '__main__'