printSeparate multiple output strings with commas, or use "+" instead of ","
2. Enterprint "李帅",“王子轩”
3. Piecemealname = raw_input()#有提示的输入：name = raw_input(‘please enter your name: ‘)print ‘hello,‘, name
4. Data Structure 4.1 list analogy to an array in Java#!/usr/bin/env python# -*- coding: utf-8 -*-+
classmates = [‘Michael‘, ‘Bob‘, ‘Tracy‘]
Use an index to access the elements of each location in the list, remembering that the index starts at 0:
Classmates[0]
If you want to take the last element, in addition to calculating the index location, you can also use 1 to index, get the last element directly:
CLASSMATES[-1]
The list is a mutable, ordered table, so you can append an element to the end of the list:
Classmates.append (' Adam ')
You can also insert an element into a specified position, such as a position with an index number of 1python
classmates.insert(1, ‘Jack‘)
p = [‘asp‘, ‘php‘]
s = [‘python‘, ‘java‘, p, ‘scheme‘]
To get ' php ' can write p[1] or s[2][1], so s can be regarded as a two-dimensional array, similar to three-dimensional, four-dimension ... arrays, but rarely used.
Tuple and list are very similar, but a tuple cannot be modified once initialized
5. Conditional judgment and cyclic 5.1-piece judgmentclassmates = (‘Michael‘, ‘Bob‘, ‘Tracy‘)
5.2 Cyclesif <条件判断1>: <执行1>elif <条件判断2>: <执行2>elif <条件判断3>: <执行3>else: <执行4>
There are two types of Python loops
names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]for name in names: print name
6. Use Dict and set6.1 dictsum = 0n = 99while n > 0: sum = sum + n n = n - 2print sum
Dict support, Dict full name dictionary, also known as map in other languages
>>> d = {‘Michael‘: 95, ‘Bob‘: 75, ‘Tracy‘: 85}>>> d[‘Michael‘]95
Dict Search Faster reason: given a name, such as ' Michael ', Dict can directly calculate Michael's corresponding storage Score "page number", that is, 95 of the memory address of the number stored, directly out, so very fast.
Compared with list, Dict has the following features:
Set is similar to Dict and is a set of keys, but does not store value. Because key cannot be duplicated, there is no duplicate key in set.
To create a set, you need to provide a list as the input collection:
s = Set ([1, 2, 3])
Functions in Python can return multiple values directly. It's actually a fake, it's returned in the form of a tuple.
__author__ = ‘shuai.li‘import mathdef distance(x, y, step, angle=45): nx = x + step * math.cos(angle) ny = y + step * math.sin(angle) return nx, ny# main functionif __name__ == "__main__": nx, ny = distance(5, 10, 1) print nx, ny>>>C:\pythonTest>python function.py>>>4.55192638387 10.8939966636
The following output can be seen as actually a tuple type
7.2 Default values for function parametersif __name__ == "__main__": r = distance(5, 10, 1) print r>>>C:\pythonTest>python function.py>>>(5.52532198881773, 10.850903524534118)
Pit of Function default value
def add_end(L=[]): L.append(‘END‘) return L>>> add_end()[‘END‘]但是，再次调用add_end()时，结果就不对了：>>> add_end()[‘END‘, ‘END‘]>>> add_end()[‘END‘, ‘END‘, ‘END‘]
The reason is that L actually in Python is a variable, it points to the object [], when used to change the value of L, then its point to change the content, so the default value of the function parameter is best an immutable object
7.3 Functions for variable parametersAdd * to the parameter to change the function parameter to a variable parameter
def cal(*numbers): sum = 0 for num in numbers: sum = sum + math.pow(num, 2) return sum# main functionif __name__ == "__main__": r = cal(1, 2) print r r1 = cal(1, 2, 3) print r1>>> C:\pythonTest>python function.py>>> 5.0>>> 14.0
But I was a tuple or list can not let me put the object of the inside one after another. No, Python provides a workaround that is to give Python the rest of the "*" Operation directly in front of your tuple or list.
7.4 parameter names with variable number of argumentsdef cal(*numbers): sum = 0 for num in numbers: sum += math.pow(num, 2) return sum# main functionif __name__ == "__main__": r = (1, 2) print cal(*r)>>> C:\pythonTest>python function.py>>> 5.0
* * This allows you to pass in 0 or more parameters with parameter names, used in cases with required parameters and non-mandatory parameters, and variable parameter functions like directly passing key value pairs in parameters, or without passing parameters
def student(name, age, **city): print name, age, city# main functionif __name__ == "__main__": city = {"city": "beijing", "street": "suzhoujie"} student("lishuai", 12, city="beijing", street="suzhoujie")>>>C:\pythonTest>python function.py>>>lishuai 12 {‘city‘: ‘beijing‘, ‘street‘: ‘suzhoujie‘}
Of course, the parameters passed in can be directly dict, so that they can be passed directly as mutable parameters.
7.5 Combination of parameter typesdef student(name, age, **city): print name, age, city[‘city‘], city[‘street‘]# main functionif __name__ == "__main__": city = {"city": "beijing", "street": "suzhoujie"} student("lishuai", 12, **city)
Defining functions in Python can be done with required parameters, default parameters, variable parameters, and keyword parameters, all of which can be used together, or only some of them, but note that the order of the parameters definition must be: required, default, variable, and keyword parameters. 4
!!! When all of these four types are available, you can pass in the tuple and dict directly. Note that at this point the tuple automatically fills in the preceding required fields so, for any function, it can be called by a Func-like (*args, **kw), regardless of how its arguments are defined.
def func(a, b, c=0, *args, **kw): print ‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘args =‘, args, ‘kw =‘, kw>>> args = (1, 2, 3, 4)>>> kw = {‘x‘: 99}>>> func(*args, **kw)a = 1 b = 2 c = 3 args = (4,) kw = {‘x‘: 99}
Using *args and **kw is a Python idiom, but it can also be used with other parameter names, but it's best to use idiomatic usage.???
After trying, it is impossible to remove the "" and "*" before the parameter.
Beware of stack overflow when recursion. The call to the function is implemented through the data structure of the stack, and each time a function call is entered, the stack is incremented by one layer, and the stack is reduced by one layer whenever the function returns. The stack inside the computed memory is limited.
The method of solving recursive call stack overflow is optimized by tail recursion, in fact, each time the function recursive is called, the parameters passed in are already calculated in advance, so the stack layer is not stacked.
9.2 Traversal__author__ = ‘shuai.li‘if __name__ == "__main__": l = ["lishuai", "wangwang", "lili", "shuai"] print l[0:3] print l[-1] print l[-3:-1] print l[-1:-3] print l[-3:] print l[::2]>>>C:\pythonTest>python special.py[‘lishuai‘, ‘wangwang‘, ‘lili‘]shuai[‘wangwang‘, ‘lili‘][][‘wangwang‘, ‘lili‘, ‘shuai‘][‘lishuai‘, ‘lili‘] #特别注意这个的用法，每两个取一个
9.3 List Builder 9.3.1 How to use it?__author__ = ‘shuai.li‘if __name__ == "__main__": student = {"name": "lishuai", "age": 12} for k, v in student.items(): print k+":"+str(v)C:\pythonTest>python iteration.pyage:12name:lishuai
The list generation, which is the comprehensions, is a very simple and powerful build of Python built-in that can be used to create lists.
Write how to generate each item (the contents of each item), followed by a few (conditions for each item), from point to line
__author__ = ‘shuai.li‘if __name__ == "__main__": print [x + x * x for x in range(0,10,2)]>>>C:\pythonTest>python listGenerate.py>>>[0, 6, 20, 42, 72]
You can add an if condition after the for loop.
if __name__ == "__main__": print [x for x in range(0, 50) if x % 3 == 0 if x % 4 == 0 ]
Note If there is an if condition later. The step is ignored by the program.
if __name__ == "__main__": print [x for x in range(0, 50, 2) if x % 3 == 0 if x % 4 == 0 ]>>>C:\pythonTest>python listGenerate.py>>>[0, 12, 24, 36, 48]
can also be multi-layer cycle
if __name__ == "__main__": print [m+n for m in ‘xyz‘ for n in ‘abc‘ ]C:\pythonTest>python listGenerate.py[‘xa‘, ‘xb‘, ‘xc‘, ‘ya‘, ‘yb‘, ‘yc‘, ‘za‘, ‘zb‘, ‘zc‘]
The preceding conditions can also be written in the form of a function
Where is 9.3.2 used?l = [‘HELLO‘, ‘Fuck‘, ‘yoU‘] print [s.lower() for s in l]
A long list needs to be listed, and each object is similar.
For example: List all files and directories in the current directory
9.4 Generatorsimport osif __name__ == "__main__":
The benefit of the generator is that the edge generates edge calculations so that it does not take up much space as the list Builder does, especially when a large list is useful.
The way to do this is to change the list-generated [] to () and create a generator:
However, we can print out each element of the list generator directly, but we cannot print out the generator's elements directly, we need to use the next () function, and we can iterate over the object using the For loop.
There is another way to do this: include the yield keyword
The hardest thing to understand is that generator is not the same as the execution of a function. The function is executed sequentially, the return statement is encountered, or the last line function statement is returned. The function that becomes generator, executes at each call to next (), encounters a yield statement return, and executes again from the yield statement that was last returned.
The effect of yield is to turn a function into a generator, the function with yield is no longer a normal function, the Python interpreter treats it as a generator, and the Call to FAB (5) does not execute the FAB function, but instead returns a Iterable Object! When the For loop executes, each loop executes the code inside the FAB function, and when it executes to yield B, the FAB function returns an iteration value, and the next iteration, the code proceeds from the next statement of Yield B, and the local variable of the function looks exactly the same as before the last break, so the function Continue execution until yield is encountered again.
A function with yield is a generator that can traverse an element using the for in iterate, or use Function.next () to traverse an element
The following is a generator that generates an integer multiplier of 3
10. Functional programming__author__ = ‘shuai.li‘# coding:utf-8# 一个返回3的整数倍的生成器def odd(n): a = 0 while n > 0: a += 3 n -= 1 yield aif __name__ == "__main__": for a in odd(5): print ainput:>>> C:\pythonTest>python generator.py3691215
Functional Programming is a very high degree of abstraction of the programming paradigm, the purely functional programming language functions are not variable, so any function, as long as the input is determined, the output is OK, this pure function we call no side effects. In the case of programming languages that allow the use of variables, because of the variable state inside the function, the same input may get different output, so this function has side effects.
One of the features of functional programming is that it allows the function itself to be passed as a parameter to another function, and also allows a function to be returned!
Python provides partial support for functional programming. Because Python allows the use of variables, Python is not a purely functional programming language.
10.1 Higher order functionsFunctions can be assigned to variables like variables
if __name__ == "__main__": f = abs print f(-1)
The above program shows that F is now pointing to the ABS function itself
So what is the function name? The function name is actually a variable pointing to the function! For the ABS () function, it is perfectly possible to think of ABS as a variable, which points to a function that calculates the absolute value!
Incoming function
def add(a, b, f): return f(a) + f(b)if __name__ == "__main__": print add(5, -10, abs)
Writing higher-order functions allows the parameters of a function to receive other functions.
10.2 map () and reduce () functionsThe map function is to pass in one function to perform the same processing for each element in the other object passed in. Reduce () is the first two elements of a subsequent object, and then the composition of an element then works with the third element until all the elements have been processed.
Converts a number in a list to a string:
Simple use of Map
if __name__ == "__main__": print map(str, [1, 2, 3, 4, 5])>>> C:\pythonTest>python mapAndreduce.py>>> [‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘]
The effect of reduce is:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
The conversion string is of type int:
10.2.1 Lambda function# str转换为int的函数def strtoint(s): # 首先要把str判断下是否全是数字类型的字符,不做 # 一个个字符转换为数字，然后数字列表 l = map(int, s) # 数字列表变成int return reduce(numtoint, l)def numtoint(a, b): return 10 * a + bif __name__ == "__main__": print strtoint("356546") print isinstance(strtoint("356546"),int)>>> C:\pythonTest>python mapAndreduce.py>>> 356546>>> True
Can be used to write single-line functions, so that when a simple logic processing need not write a function to deal with, directly with the lambda to handle
This can be said to simplify the above function:
10.2.2 Practice# str转换为int的函数def strtoint(s): # 首先要把str判断下是否全是数字类型的字符,不做 # 一个个字符转换为数字，然后数字列表 l = map(int, s) # 数字列表变成int return reduce(lambda x, y: 10 * x + y, l)if __name__ == "__main__": print strtoint("356546") print isinstance(strtoint("356546"), int)
1. Using the map () function, the user input of the non-standard English name, the first letter capitalized, other lowercase canonical name. Input: [' Adam ', ' Lisa ', ' Bart '], output: [' Adam ', ' Lisa ', ' Bart '].
if __name__ == "__main__": print map(lambda s:s[0].upper()+s[1:].lower(),[‘adam‘, ‘LISA‘, ‘barT‘])>>> C:\pythonTest>python exersize1.py>>> [‘Adam‘, ‘Lisa‘, ‘Bart‘]
The sum () function provided by 2.Python can accept a list and sum, write a prod () function that accepts a list and uses the reduce () to calculate the product.
10.3 Filterdef prod(l): if not isinstance(l, list): return "错误的输入参数类型" else: return reduce(lambda x, y: x + y, l)if __name__ == "__main__": print prod([23,34,1,2])
Like map (), filter () also receives a function and a sequence. When different from map (), filter () applies the incoming function to each element sequentially, and then decides whether to persist or discard the element based on whether the return value is true or false.
10.4 Sortif __name__ == "__main__": print filter(lambda x: x % 2 == 0, range(1, 100))
Generally, for two elements x and Y, if you think X < Y, then return-1, if you think x = = y, then return 0, if you think x > Y, then return 1, so that the sorting algorithm does not care about the specific comparison process, but based on the results of the comparison directly sorted. So we need to rewrite the sorting algorithm.
Functions in reverse order
11 Advanced Functions 11.1 anonymous functionsdef revert(x, y): if x > y: return -1 elif x == y: return 0 else: return 1if __name__ == "__main__": print sorted([34, 67, 89, 32, 56, 23, 12, 567, 3], revert)>>> C:\pythonTest>python filter.py>>> [567, 89, 67, 56, 34, 32, 23, 12, 3]
What if you do not need to sum immediately, but in the later code, as necessary to calculate what to do? You can return the SUM function without returning the result of the summation!
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum
When we call Lazy_sum (), we return the SUM function instead of summing the result:
>>> f = lazy_sum(1, 3, 5, 7, 9)>>> f<function sum at 0x10452f668>
The result of summing is actually computed when the function f is called:
>>> f()25
In this example, we define the function sum in the function lazy_sum, and the inner function sum can refer to the arguments and local variables of the external function lazy_sum, and when Lazy_sum returns the function sum, the relevant parameters and variables are stored in the returned function, which is called The program structure of the "Closure (Closure)" has great power.
Note again that when we call Lazy_sum (), each call returns a new function, even if the same parameter is passed in:
>>> f1 = lazy_sum(1, 3, 5, 7, 9)>>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> f1==f2False
The invocation results of F1 () and F2 () do not affect each other.
11.2 DecoratorsMy own understanding:
followed by a function, the following function is given to the function after the @ as a parameter.
The adorner has an intrinsic function that returns the function after it has been processed and returns the adorner.
12 Modulesdef log(func): def wrapper(*args, **kw): print ‘call %s():‘ % func.__name__ return func(*args, **kw) return wrapper@logdef sum(): print "lishuai"if __name__ == "__main__": sum()
In Python, a. py file is called a module
To avoid module name collisions, Python introduces a way to organize modules by directory, called packages.
1) Why should I have modules and packages?
Easy to organize your code while avoiding conflicts.
2) How to represent a package?
Under each package directory there will be an init. py file, which must exist, otherwise Python will treat this directory as a normal directory instead of a package. The init. PY can be an empty file, or it can have Python code because the init. PY is itself a module, and its module name is MyCompany.
3) How to determine the name of the module?
Name of package name + module
12.1.2 importing modules using aliasesif __name__==‘__main__‘: test()当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。
The advantage is that the library can be selected according to the actual
try: import cStringIO as StringIOexcept ImportError: # 导入失败会捕获到ImportError import StringIO
In a module, we may define many functions and variables, but some functions and variables we want to use for others, some functions and variables we want to use only within the module. In Python, this is done through the _ prefix.
Normal functions and variable names are public and can be directly referenced, for example: ABC,X123,PI, etc.;
Such variables like xxx are special variables, can be directly referenced, but for special purposes, such as the above author,name is a special variable, hello module definition of the document comments can also be used with special variables Doc access, our own variables are generally not used in this variable name;
functions or variables such as _xxx and XXX are nonpublic (private) and should not be referenced directly, such as _ABC,ABC, etc.;
The reason why we say thatprivate functions and variables "should not be" directly referenced, rather than "cannot" be directly referenced, is because Python does not have a way to completely restrict access to private functions or variables, however, The private function or variable should not be referenced from the programming habit.
12.2 Search Path of the moduleBy default, the Python interpreter searches the current directory, all installed built-in modules, and third-party modules, and the search path is stored in the PATH variable of the SYS module:
If we want to add our own search directory, there are two ways:
One is to modify the Sys.path directly and add the directories to be searched:
>>> import sys>>> sys.path.append(‘/Users/michael/my_py_scripts‘)
This method is modified at run time and is invalidated after the run is finished.
The second method is to set the environment variable Pythonpath, and the contents of the environment variable are automatically added to the module search path. Settings are similar to setting the PATH environment variable. Note that you only need to add your own search path, and Python's own search path is unaffected.
Python Self-study notes
Start building with 50+ products and up to 12 months usage for Elastic Compute Service
1 on 1 presale consultation
24/7 Technical Support 6 Free Tickets per Quarter Faster Response
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.
A comprehensive suite of global cloud computing services to power your business
Payment Methods We Support
