本文作者BisratYalew共享了自己在项目中使用过的Python代码片段，希望能帮到其他开发人员，以减少时间并简化开发流程，该项目内容包含：String、Number、File、Functions、Classes、Date and Time、Regular Expressions、Web Data Handling、Asyncio以及Socket。

Python Strings

• strip
• lstrip
• rstrip
• upper
• isupper
• lower
• islower
• in
• not in
• ord
• Template Strings
• Pyperclip module

strip()

>>> check = '    Python is great!     '  # removes characters from both left and right based on the argument
>>> check.strip()
'Python is great'

lstrip()

>>> check.lstrip()
'Python is great!     ' ## removes characters from left based on the argument

rstrip()

>>> check.rstrip() ## removes characters from left based on the argument
'     Python is great!'

ord()

>>> ord('A'), ord('Z')
(65, 90)
>>> ord('0'), ord('9')
(48, 57)
>>> ord('a'), ord('z')
(97, 122)
>>> ord('B'), ord('Y')
(66, 89)

The in and not in Operators with string

>>> 'Python' in 'Python is great!'
True
>>> 'python' in 'Python'
False
>>> 'PYTHON' in 'Python is great!'
False
>>> '' in 'python'
True
>>> 'Python' not in 'python and javascript' ## Matches case
True

The in and not in Operators with list

>>> a = ['P', 'y', 't', 'h', 'o', 'n']
>>> 'p' in a
False
>>> 'P' in a
True
>>> 'o' in a
True

## On Integers List
>>> a = [1, 2, 3, 5]
>>> 5 in a
True
>>> 4 in a
False
>>> 1 in a
True

The upper(), lower(), isupper(), islower() string methods

>>> check = 'Hello world!'
>>> check = check.lower() ## converts check to lower
>>> check
'hello world!'
>>> check = check.isupper() ## checks whether check variable is upper or not. 
False
>>> check = check.islower() ## checks whether check variable is upper or not. 
True
>>> check = check.upper() ## converts check to upper
>>> check
'HELLO WORLD!'
>>> check = check.isupper() ## checks whether check variable is upper or not. 
True
>>> check = check.islower() ## checks whether check variable is upper or not. 
False

Template Strings

模板字符串是一种更简单的机制，用于处理用户生成的格式字符串

>>> from string import Template
>>> language = 'Python'
>>> t = Template('$name is great!')
>>> t.substitute(name=language) ## Substitutes name with language variable
'Python is great!'
#####Pyperclip
Pyperclip是一个Python库，可以帮助我们轻松复制和粘贴字符串
首先使用pip安装

pip install pyperclip

​```
>>> import pyperclip
>>> pyperclip.copy('Hello World') ## Copy Hello World
>>> pyperclip.paste()
'Hello World'

Number

Python中有三种数字类型

• int (e.g. 2, 4, 20)
  bool (e.g. False and True, acting like 0 and 1)
• float (e.g. 5.0, 1.6)
• complex (e.g. 5+6j, 4-3j)

Basic Functions

a = pow(2, 3) ## Or: 2 ** 3
b = abs(5) ## <real> = abs(<num>)

Constants

from math import e, pi

Trigonometry

from math import cos, acos, sin, asin, tan, atan, degrees, radians

Logarithm

from math import log, log10, log2
<float> = log(<real> [, base])  # Base e, if not specified.

Infinity, nan

from math import inf, nan, isinf, isnan

Or:

float('inf'), float('nan')

Statistics

from statistics import mean, median, variance, pvariance, pstdev

Random

from random import random, randint, choice, shuffle
<float> = random()
<int>   = randint(from_inclusive, to_inclusive)
<el>    = choice(<list>)
shuffle(<list>)

Combinatorics

每个函数都返回一个迭代器。
如果要打印迭代器，需要将其传递给list（）函数！

from itertools import product, combinations, combinations_with_replacement, permutations
>>> product([0, 1], repeat=3)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), 
 (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]

>>> product('ab', '12')
[('a', '1'), ('a', '2'),
 ('b', '1'), ('b', '2')]

>>> combinations('abc', 2)
[('a', 'b'), ('a', 'c'), ('b', 'c')]

>>> combinations_with_replacement('abc', 2)
[('a', 'a'), ('a', 'b'), ('a', 'c'), 
 ('b', 'b'), ('b', 'c'), 
 ('c', 'c')]

>>> permutations('abc', 2)
[('a', 'b'), ('a', 'c'), 
 ('b', 'a'), ('b', 'c'), 
 ('c', 'a'), ('c', 'b')]

"""
def test_integer_numbers():
    """Integer type
    Int, or integer, is a whole number, positive or negative,
    without decimals, of unlimited length.
    """

    positive_integer = 1
    negative_integer = -3255522
    big_integer = 35656222554887711

    assert isinstance(positive_integer, int)
    assert isinstance(negative_integer, int)
    assert isinstance(big_integer, int)


def test_booleans():
    """Boolean
    Booleans represent the truth values False and True. The two objects representing the values
    False and True are the only Boolean objects. The Boolean type is a subtype of the integer type,
    and Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the
    exception being that when converted to a string, the strings "False" or "True" are returned,
    respectively.
    """

    true_boolean = True
    false_boolean = False

    assert true_boolean
    assert not false_boolean

    assert isinstance(true_boolean, bool)
    assert isinstance(false_boolean, bool)

    # Let's try to cast boolean to string.
    assert str(true_boolean) == "True"
    assert str(false_boolean) == "False"


def test_float_numbers():
    """Float type
    Float, or "floating point number" is a number, positive or negative,
    containing one or more decimals.
    """

    float_number = 7.0
    # Another way of declaring float is using float() function.
    float_number_via_function = float(7)
    float_negative = -35.59

    assert float_number == float_number_via_function
    assert isinstance(float_number, float)
    assert isinstance(float_number_via_function, float)
    assert isinstance(float_negative, float)

    # Float can also be scientific numbers with an "e" to indicate
    # the power of 10.
    float_with_small_e = 35e3
    float_with_big_e = 12E4

    assert float_with_small_e == 35000
    assert float_with_big_e == 120000
    assert isinstance(12E4, float)
    assert isinstance(-87.7e100, float)


def test_complex_numbers():
    """Complex Type"""

    complex_number_1 = 5 + 6j
    complex_number_2 = 3 - 2j

    assert isinstance(complex_number_1, complex)
    assert isinstance(complex_number_2, complex)
    assert complex_number_1 * complex_number_2 == 27 + 8j


def test_number_operators():
    """Basic operations"""

    # Addition.
    assert 2 + 4 == 6

    # Multiplication.
    assert 2 * 4 == 8

    # Division always returns a floating point number.
    assert 12 / 3 == 4.0
    assert 12 / 5 == 2.4
    assert 17 / 3 == 5.666666666666667

    # Modulo operator returns the remainder of the division.
    assert 12 % 3 == 0
    assert 13 % 3 == 1

    # Floor division discards the fractional part.
    assert 17 // 3 == 5

    # Raising the number to specific power.
    assert 5 ** 2 == 25  # 5 squared
    assert 2 ** 7 == 128  # 2 to the power of 7

    # There is full support for floating point; operators with
    # mixed type operands convert the integer operand to floating point.
    assert 4 * 3.75 - 1 == 14.0

File

• Read File
• Write a File
• Copy File
• Move File
• Readline

Read a file

在Python 3中，如果文件未以二进制模式打开，则编码将由locale.getpreferredencoding（False）或用户输入确定。

>>> with open("/etc/hosts", encoding="utf-8") as f:
...     content = f.read()
...
>>> print(type(content))
<class 'str'>

In python3 binary mode

>>> with open("/etc/hosts", "rb") as f:
...     content = f.read()
...
>>> print(type(content))
<class 'bytes'>

In python2

## The content of the file is a byte string, not a Unicode string.
>>> with open("/etc/passwd") as f:
...    content = f.read()
>>> print(type(content))
<type 'str'>
>>> print(type(content.decode("utf-8")))
<type 'unicode'>

Write a File

>>> file_content = "Python is great!"
>>> with open("check.txt", "w") as file:
...     file.write(file_content)

Copy a file

>>> from distutils.file_util import copy_file
>>> copy_file("a", "b")
('b', 1)

Move a File

>>> from distutils.file_util import move_file
>>> move_file("./a", "./b")
'./b'

Readline

## If you are not using linux machine try to change the file path to read
>>> with open("/etc/hosts") as f:
...     for line in f:
...         print(line, end='')
...
127.0.0.1       localhost
255.255.255.255     broadcasthost
::1             localhost

Python Functions

• Lambda
• Declare Function
• Document Function
• Get Function Name
• Arguments
• Decorator
• Generator

Lambda

>>> fn = lambda x: x**3
>>> fn(2)
8

>>> (lambda x: x**3)(2)
8

>>> (lambda x: [x * _ for _ in range(10)])(3)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Declare Function

def fn_name(): ## Where fn_name represents the function name
    ........
    ........

Get Function Name

## First Declare a function 
def fn_name():
    .......
    .......

>>> fn_name.__name__
'fn_name'

Document a Function

## Document a function with three single quotes
def check():
    '''This function is documented'''
    return

>>> check.__doc__
'This function is documented'

Arguments

>>> def multiply(a, b=0): ## b is 0 by default
...     return a * b
...
>>> multiply(1, 3) ## 3 * 1
3
>>> multiply(5) ## 5 * 0
0
>>> multiply(5, b=3) ## 5 * 3
15

Generator

def count(start, step):
    while True:
        yield start
        start += step

>>> counter = count(10, 5)
>>> next(counter)
(15)

>>> next(counter) ## Increments by 5 from the previous result
(20)

>>> next(counter)
(25)

>>> next(counter), next(counter), next(counter)
(30, 35, 40)

Decorator

>>> from functools import wraps

>>> def decorator_func(func):
...     @wraps(func)
...     def wrapper(*args, **kwargs):
...         print("Before calling {}.".format(func.__name__))
...         ret = func(*args, **kwargs)
...         print("After calling {}.".format(func.__name__))
...         return ret
...     return wrapper
...
>>> @decorator_func
... def check():
...     print("Inside check function.")
...
>>> check()
Before calling check.
Inside check function.
After calling check.

Classes

• Definition
• Class Objects
• Instance Objects
• Method Objects
• Inheritance
• Multiple Inheritance

Class Definition

Python是一种面向对象的编程语言。 Python中的几乎所有东西都是一个对象，具有其属性和方法。 Class类似于对象构造函数，或者是用于创建对象的“蓝图”。

def test_class():
    """Class definition."""

    # Class definitions, like function definitions (def statements) must be executed before they
    # have any effect. (You could conceivably place a class definition in a branch of an if
    # statement, or inside a function.)

    class GreetingClass:
        """Example of the class definition
        This class contains two public methods and doesn't contain constructor.
        """
        name = 'Bisrat'

        def say_hello(self):
            """Class method."""
            # The self parameter is a reference to the class itself, and is used to access variables
            # that belongs to the class. It does not have to be named self , you can call it
            # whatever you like, but it has to be the first parameter of any function in the class.
            return 'Hello ' + self.name

        def say_goodbye(self):
            """Class method."""
            return 'Goodbye ' + self.name

    # When a class definition is entered, a new namespace is created, and used as the local scope —
    # thus, all assignments to local variables go into this new namespace. In particular, function
    # definitions bind the name of the new function here.

    # Class instantiation uses function notation. Just pretend that the class object is a
    # parameterless function that returns a new instance of the class. For example the following
    # code will creates a new instance of the class and assigns this object to the local variable.
    greeter = GreetingClass()

    assert greeter.say_hello() == 'Hello Bisrat'
    assert greeter.say_goodbye() == 'Goodbye Bisrat'

>>> print(type(content))
<class 'str'>

Class Objects

def test_class_objects():
    """Class Objects.
    Class objects support two kinds of operations:
    - attribute references
    - instantiation.
    """

    # ATTRIBUTE REFERENCES use the standard syntax used for all attribute references in
    # Python: obj.name. Valid attribute names are all the names that were in the class’s namespace
    # when the class object was created. For class MyCounter the following references are valid
    # attribute references:

    class ComplexNumber:
        """Example of the complex numbers class"""

        real = 0
        imaginary = 0

        def get_real(self):
            """Return real part of complex number."""
            return self.real

        def get_imaginary(self):
            """Return imaginary part of complex number."""
            return self.imaginary

    assert ComplexNumber.real == 0

    # __doc__ is also a valid attribute, returning the docstring belonging to the class
    assert ComplexNumber.__doc__ == 'Example of the complex numbers class'

    # Class attributes can also be assigned to, so you can change the value of
    # ComplexNumber.counter by assignment.
    ComplexNumber.real = 10
    assert ComplexNumber.real == 10

    # CLASS INSTANTIATION uses function notation. Just pretend that the class object is a
    # parameterless function that returns a new instance of the class. For example
    # (assuming the above class):
    complex_number = ComplexNumber()

    assert complex_number.real == 10
    assert complex_number.get_real() == 10

    # Let's change counter default value back.
    ComplexNumber.real = 10
    assert ComplexNumber.real == 10

    # The instantiation operation (“calling” a class object) creates an empty object. Many classes
    # like to create objects with instances customized to a specific initial state. Therefore a
    # class may define a special method named __init__(), like this:

    class ComplexNumberWithConstructor:
        """Example of the class with constructor"""
        def __init__(self, real_part, imaginary_part):
            self.real = real_part
            self.imaginary = imaginary_part

        def get_real(self):
            """Return real part of complex number."""
            return self.real

        def get_imaginary(self):
            """Return imaginary part of complex number."""
            return self.imaginary

    complex_number = ComplexNumberWithConstructor(3.0, -4.5)
    assert complex_number.real, complex_number.imaginary == (3.0, -4.5)

Instance Object

def test_instance_objects():
    # DATA ATTRIBUTES need not be declared; like local variables, they spring into existence when
    # they are first assigned to. For example, if x is the instance of MyCounter created above,
    # the following piece of code will print the value 16, without leaving a trace.

    # pylint: disable=too-few-public-methods
    class DummyClass:
        pass

    dummy_instance = DummyClass()

    # pylint: disable=attribute-defined-outside-init
    dummy_instance.temporary_attribute = 1
    assert dummy_instance.temporary_attribute == 1
    del dummy_instance.temporary_attribute

Method Objects

class MyCounter:
    """A simple example of the counter class"""
    counter = 10

    def get_counter(self):
        """Return the counter"""
        return self.counter

    def increment_counter(self):
        """Increment the counter"""
        self.counter += 1
        return self.counter


def test_method_objects():
    """Method Objects."""


    # object types can have methods as well. For example, list objects have methods called append,

    counter = MyCounter()
    assert counter.get_counter() == 10

    get_counter = counter.get_counter
    assert get_counter() == 10



    assert counter.get_counter() == 10
    assert MyCounter.get_counter(counter) == 10

Inheritance

# pylint: disable=too-few-public-methods
class Person:
    """Example of the base class"""
    def __init__(self, name):
        self.name = name

    def get_name(self):
        """Get person name"""
        return self.name


# The syntax for a derived class definition looks like this.
class Employee(Person):

    def __init__(self, name, staff_id):
        Person.__init__(self, name)
        # You may also use super() here in order to avoid explicit using of parent class name:
        # >>> super().__init__(name)
        self.staff_id = staff_id

    def get_full_id(self):
        """Get full employee id"""
        return self.get_name() + ', ' + self.staff_id


def test_inheritance():
    """Inheritance."""

    # There’s nothing special about instantiation of derived classes: DerivedClassName() creates a
    # new instance of the class. Method references are resolved as follows: the corresponding class
    # attribute is searched, descending down the chain of base classes if necessary, and the method
    # reference is valid if this yields a function object.
    person = Person('Bisrat')
    employee = Employee('John', 'A23')

    assert person.get_name() == 'Bisrat'
    assert employee.get_name() == 'John'
    assert employee.get_full_id() == 'John, A23'

    # Python has two built-in functions that work with inheritance:
    #
    # - Use isinstance() to check an instance’s type: isinstance(obj, int) will be True only if
    # obj.__class__ is int or some class derived from int.
    #
    # - Use issubclass() to check class inheritance: issubclass(bool, int) is True since bool is
    # a subclass of int. However, issubclass(float, int) is False since float is not a subclass
    # of int.

    assert isinstance(employee, Employee)
    assert not isinstance(person, Employee)

    assert isinstance(person, Person)
    assert isinstance(employee, Person)

    assert issubclass(Employee, Person)
    assert not issubclass(Person, Employee)

Multiple Inheritance

def test_multiple_inheritance():
    """Multiple Inheritance"""
    class Clock:
        """Clock class"""

        time = '10:17 PM'

        def get_time(self):
            """Get current time
            Method is hardcoded just for multiple inheritance illustration.
            """
            return self.time


    class Calendar:
        """Calendar class"""

        date = '12/08/2018'

        def get_date(self):
            """Get current date
            Method is hardcoded just for multiple inheritance illustration.
            """
            return self.date

    # Python supports a form of multiple inheritance as well. A class definition with multiple
    # base classes looks like this.
    class CalendarClock(Clock, Calendar):

    calendar_clock = CalendarClock()

    assert calendar_clock.get_date() == '12/08/2018'
    assert calendar_clock.get_time() == '11:23 PM'

Date and Time

• DateTime
• Time Delta
• Calendar

datetime

from datetime import date 
from datetime import time
from datetime import datetime

>>> today = date.today()
>>> print(today)
2019-03-04

>>> print(today.day, today.month, today.year)
(4, 3, 2019)

>>> print(today.weekday()) ## returns an integers in the range 0 to 6, where 0 represents Monday and 6 represents Sunday.
0

>>> today = datetime.now()
>>> print(today)
2019-03-04 21:55:56.228000

>>> time = datetime.time(datetime.now())
>>> print(time) 
21:56:16.040000

Time Delta

This module is used to perform date and time calculations.

from datetime import date 
from datetime import time
from datetime import datetime
from datetime import timedelta

print(timedelta(days=365, hours=5, minutes=1)) # 365 days, 5:01:00
today  = datetime.now()
print(today + timedelta(days=60)) # 2019-03-29 18:41:46.720811
print(today - timedelta(days=57)) # 2018-12-02 18:42:36.774421

timedelta对象采用以下参数：天，秒，微秒，毫秒，分钟，小时，周。 要查找过去或将来的日期，只需使用带有当前日期所需差异的加号或减号。

Calendar

日历相关操作并以格式化方式显示

import calendar

c = calendar.TextCalendar(calendar.MONDAY)
st = c.formatmonth(2017, 1, 0,0)
print(st)

hc = calendar.HTMLCalendar(calendar.MONDAY)
st = hc.formatmonth(2017, 1)
print(st)

#Output
'''
    January 2017
Mo Tu We Th Fr Sa Su
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31

<table border="0" cellpadding="0" cellspacing="0" class="month">
<tr><th colspan="7" class="month">January 2017</th></tr>
<tr><th class="mon">Mon</th><th class="tue">Tue</th><th class="wed">Wed</th><th class="thu">Thu</th><th class="fri">Fri</th><th class="sat">Sat</th><th class="sun">Sun</th></tr>
<tr><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="sun">1</td></tr>
<tr><td class="mon">2</td><td class="tue">3</td><td class="wed">4</td><td class="thu">5</td><td class="fri">6</td><td class="sat">7</td><td class="sun">8</td></tr>
<tr><td class="mon">9</td><td class="tue">10</td><td class="wed">11</td><td class="thu">12</td><td class="fri">13</td><td class="sat">14</td><td class="sun">15</td></tr>
<tr><td class="mon">16</td><td class="tue">17</td><td class="wed">18</td><td class="thu">19</td><td class="fri">20</td><td class="sat">21</td><td class="sun">22</td></tr>
<tr><td class="mon">23</td><td class="tue">24</td><td class="wed">25</td><td class="thu">26</td><td class="fri">27</td><td class="sat">28</td><td class="sun">29</td></tr>
<tr><td class="mon">30</td><td class="tue">31</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td><td class="noday">&nbsp;</td></tr>
</table>
'''

.HTMLCalendar以表格的形式返回HTML代码。Calendar.SUNDAY表示格式化日历中的第一天是星期日，在上边的例子中，使用了Calendar.MONDAY。因此，我们可以在输出中看到表示中的第一天是星期一。

Iterating through dates of a month

import calendar

c = calendar.TextCalendar(calendar.MONDAY)
for i in c.itermonthdays(2017, 8):
    print(i, end = ' ')
print('')
for name in calendar.month_name:
    print(name, end = ' ')
print('')
for day in calendar.day_name:
    print(day, end = ' ')
'''
Output:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 0 0
 January February March April May June July August September October November December
Monday Tuesday Wednesday Thursday Friday Saturday Sunday
'''

Regular Expressions

非特殊字符匹配

Regular Expression Examples

Web Data Handling

• Make a Request
• Read
• Get Code
• HTML Parsing
• JSON Parsing
• XML Parsing

Make a Request

import urllib.request ## urllib module is used to send request and receive response from a server. It can used to get html / JSON / XML data from an api.

webData = request.urlopen("http://www.google.com") ## It opens a connection to google.com and returns an object of class http.client.HTTPResponse

Read
.read()返回网页的HTML数据。

Get Code
.getcode() 返回连接建立的状态代码。

HTML Parsing

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
    def error(self, message):
        pass

parser = MyHTMLParser()
f = open("check.html")
if f.mode == 'r':  # file successfully opened
    contents = f.read()
    parser.feed(contents)

JSON Parsing

import json
json_data = json.loads(response)

XML Parsing

import xml.dom.minidom
doc = minidom.parse("check.xml")

Asyncio

• Definition
• asyncio.run
• Socket with Asyncio
• Move File
• Readline

asyncio是Python 3.5中包含的一个库，采用非常非常明确的异步编程方法：只有标记为async的方法编写的代码才能以异步方式调用任何代码。

asyncio.run

Python 3.7中的新功能

>>> import asyncio
>>> from concurrent.futures import ThreadPoolExecutor

>>> e = ThreadPoolExecutor()
>>> async def read_file(file_):
...     loop = asyncio.get_event_loop()
...     with open(file_) as f:
...         return (await loop.run_in_executor(e, f.read))
...
>>> ret = asyncio.run(read_file('/etc/passwd'))

Socket with Asyncio

import asyncio
import socket

host = 'localhost'
port = 9527
loop = asyncio.get_event_loop()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setblocking(False)
s.bind((host, port))
s.listen(10)

async def handler(conn):
    while True:
        msg = await loop.sock_recv(conn, 1024)
        if not msg:
            break
        await loop.sock_sendall(conn, msg)
    conn.close()

async def server():
    while True:
        conn, addr = await loop.sock_accept(s)
        loop.create_task(handler(conn))

loop.create_task(server())
loop.run_forever()
loop.close()

output: (bash 1)

$ nc localhost 9527
Hello
Hello

output: (bash 2)

$ nc localhost 9527
World
World

Socket

获取主机名

文件传输协议（ftp）客户端

文件传输协议（ftp）服务器

Get Hostname

>>> import socket
>>> socket.gethostname()
'root@bisratyalew'

>>> hostname = socket.gethostname()

>>> socket.gethostbyname('localhost')
'127.0.0.1'

>>> socket.gethostbyname(hostname) ### Returns ip address
'192.168.1.3'

FTP Client

import socket                   # Import socket module

port = 60000                    # Reserve a port for your service.
s = socket.socket()             # Create a socket object
host = socket.gethostname()     # Get local machine name
s.bind((host, port))            # Bind to the port
s.listen(5)                     # Now wait for client connection.

print('Server listening....')

while True:
    conn, addr = s.accept()     # Establish connection with client.
    print('Got connection from', addr)
    data = conn.recv(1024)
    print('Server received', repr(data))

    filename = 'mytext.txt'
    with open(filename, 'rb') as f:
        in_data = f.read(1024)
        while in_data:
            conn.send(in_data)
            print('Sent ', repr(in_data))
            in_data = f.read(1024)

    print('Done sending')
    conn.send('Thank you for connecting')
    conn.close()


# client side server

import socket                   # Import socket module

s = socket.socket()             # Create a socket object
host = socket.gethostname()     # Get local machine name
port = 60000                    # Reserve a port for your service.

s.connect((host, port))
s.send("Hello server!")

with open('received_file', 'wb') as f:
    print('file opened')
    while True:
        print('receiving data...')
        data = s.recv(1024)
        print('data=%s', (data))
        if not data:
            break
        # write data to a file
        f.write(data)

f.close()
print('Successfully get the file')
s.close()
print('connection closed')

FTP Server

"""
    File transfer protocol used to send and receive files using FTP server.
    Use credentials to provide access to the FTP client 
"""

from ftplib import FTP
ftp = FTP('xxx.xxx.x.x')  # Enter the ip address or the domain name here
ftp.login(user='username', passwd='password')
ftp.cwd('/Enter the directory here/')

"""
    The file which will be received via the FTP server
    Enter the location of the file where the file is received
"""

def recieve_file():
    file_name = 'example.txt'   """ Enter the location of the file """
    with open(file_name, 'wb') as LocalFile:
        ftp.retrbinary('RETR ' + file_name, LocalFile.write, 1024)
    ftp.quit()

"""
    The file which will be sent via the FTP server
    The file send will be send to the current working directory
"""

def send_file():
    file_name = 'example.txt'   """ Enter the name of the file """
    with open(file_name, 'rb') as LocalFile:
        ftp.storbinary('STOR ' + file_name, LocalFile)
    ftp.quit()

项目地址：

https://github.com/BisratYalew/python-cheatsheet