精华内容
下载资源
问答
  • 10个Python编程小技巧,让你的代码更上一层楼

    多人点赞 热门讨论 2021-06-10 17:32:35
    Python之禅 先找到终端运行python,然后输入import this,就可以得到下面的python彩蛋 The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better ...

    Python之禅

    先找到终端运行python,然后输入import this,就可以得到下面的python彩蛋

    The Zen of Python, by Tim Peters
    
    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!
    

    1.变量值交换

    • 普通用法
    temp = a 
    a = b 
    b = temp	
    
    • 简单用法
    a, b = b, a
    

    2.字符串格式化

    name = "hello"
    country = "China"
    age = 34
    
    print("Hi , i am "+ name + ". i am from " + country + ".And i am " + str(age) + ".")
    
    • 优化
    name = "hello"
    country = "China"
    age = 34
    
    print("Hi , i am %s. i am from %s. And i am %d."%(name,country,age))
    
    • 继续优化,format可以使用索引
    name = "hello"
    country = "China"
    age = 34
    
    print("Hi , i am {0}. i am from {1}. And i am{2}. Yes ,i am {0}".format(name,contry,age))
    
    • python3.6以上的写法(f-string),花括号可以写任意表达式,所以可以填写函数返回值
    name = "hello"
    country = "China"
    age = 34
    
    print(f"Hi , i am {name}. i am from {country}. And i am {age+2}. ")
    

    3.yield

    斐波那契函数

    def fibonacci(n):
    	a = 0
    	b = 1
    	nums = []
    	for _ in range(n):
    		nums.append(a)
    		a,b = b,a+b
    	return nums
    
    for i in fibonacci(10):
    	print(i)
    

    output

    在这里插入图片描述

    • yield表示,每当我们计算出一个元素,就立马将这个元素给送出去,也就是外边的print会立即输出这个数
    def fibonacci(n):
    	a = 0
    	b = 1
    	for _ in range(n):
    		yield a
    		a,b = b,a+b
    	return nums
    
    for i in fibonacci(10):
    	print(i)
    
    • yield的好处是在非常耗时的操作可以使用yield,比如在网上下载系列文档,我们就可以先输出下载好的文档内容,无需等待所有文档下载完毕

    4.列表解析式

    • 将list中所有的元素大写
    name = ["lisi","zhangsan","wangwu"]
    
    name = [x.upper() for x in name]
    
    • 找出list中所有包含a的元素
    name = [x for x in name if x.startswith("a")]
    

    5.Enumerate()函数

    可以获得循环中数组的索引值

    name = ["lisi","zhangsan","wangwu"]
    
    for i, x in enumrate(name):
    	print(i, x)
    

    6.反向遍历

    • 反向遍历数组中的值
    name = ["lisi","zhangsan","wangwu"]
    
    for i, x in enumrate(reversed(name)):
    	print(i, x)
    
    • 按顺序遍历

    按照字典顺序排列元素

    name = ["lisi","zhangsan","wangwu"]
    
    for i, x in enumrate(sorted(name)):
    	print(i, x)
    

    7.字典的合并操作

    **是解包,相当于将a和b中的所有元素写到了c中

    a = {"name": "lisi","school": "htu"}
    b = {"name": "zhangsan","school": "Beijing"}
    
    c = {**a, **b}
    

    8.三元运算

    a = "pass" if score > 60 else "fail"
    

    9.序列解包

    这个序列不一定是list,也可以是tuple、range等

    name = "li si"
    
    first_name, last_name = name.split()
    first_name = li
    last_name = si
    

    10.With语句

    读取文件后,不要忘了关闭文件

    f = open("somefile.txt", "r")
    s = f.read()
    f.close()
    

    优化就是使用with,这样就不需要手动调用close()来关闭文件

    with open("somefile.txt", "r") as f:
    	s = f.read()
    

    E = m c 2 E = mc^2 E=mc2

    展开全文
  • 而如果你之前是一个c,c++,java的程序员,同时在学习python,或者干脆就是一个刚刚学习编程的新手,那么你应该会看到很多特别有用能让你感到惊奇的实用技巧,就像我当初一样。每一个技巧和语言用法都会在一个个实例中...

    这篇博客其实就是这个集合整理后一部分的公开亮相。如果你已经是个python大牛,那么基本上你应该知道这里面的大多数用法了,但我想你应该也能发现一些你不知道的新技巧。而如果你之前是一个c,c++,java的程序员,同时在学习python,或者干脆就是一个刚刚学习编程的新手,那么你应该会看到很多特别有用能让你感到惊奇的实用技巧,就像我当初一样。

    每一个技巧和语言用法都会在一个个实例中展示给大家,也不需要有其他的说明。我已经尽力把每个例子弄的通俗易懂,但是因为读者对python的熟悉程度不同,仍然可能难免有一些晦涩的地方。所以如果这些例子本身无法让你读懂,至少这个例子的标题在你后面去google搜索的时候会帮到你。

    整个集合大概是按照难易程度排序,简单常见的在前面,比较少见的在最后。

    1.1 拆箱

    >>> a, b, c = 1, 2, 3

    >>> a, b, c

    (1, 2, 3)

    >>> a, b, c = [1, 2, 3]

    >>> a, b, c

    (1, 2, 3)

    >>> a, b, c = (2 * i + 1 for i in range(3))

    >>> a, b, c

    (1, 3, 5)

    >>> a, (b, c), d = [1, (2, 3), 4]

    >>> a

    1

    >>> b

    2

    >>> c

    3

    >>> d

    4

    1.2 拆箱变量交换

    >>> a, b = 1, 2

    >>> a, b = b, a

    >>> a, b

    (2, 1)

    1.3 扩展拆箱(只兼容python3)

    >>> a, *b, c = [1, 2, 3, 4, 5]

    >>> a

    1

    >>> b

    [2, 3, 4]

    >>> c

    5

    1.4 负数索引

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    >>> a[-1]

    10

    >>> a[-3]

    8

    1.5 切割列表

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    >>> a[2:8]

    [2, 3, 4, 5, 6, 7]

    1.6 负数索引切割列表

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    >>> a[-4:-2]

    [7, 8]

    1.7指定步长切割列表

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    >>> a[::2]

    [0, 2, 4, 6, 8, 10]

    >>> a[::3]

    [0, 3, 6, 9]

    >>> a[2:8:2]

    [2, 4, 6]

    1.8 负数步长切割列表

    >>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

    >>> a[::-1]

    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

    >>> a[::-2]

    [10, 8, 6, 4, 2, 0]

    1.9 列表切割赋值

    >>> a = [1, 2, 3, 4, 5]

    >>> a[2:3] = [0, 0]

    >>> a

    [1, 2, 0, 0, 4, 5]

    >>> a[1:1] = [8, 9]

    >>> a

    [1, 8, 9, 2, 0, 0, 4, 5]

    >>> a[1:-1] = []

    >>> a

    [1, 5]

    1.10 命名列表切割方式

    >>> a = [0, 1, 2, 3, 4, 5]

    >>> LASTTHREE = slice(-3, None)

    >>> LASTTHREE

    slice(-3, None, None)

    >>> a[LASTTHREE]

    [3, 4, 5]

    1.11 列表以及迭代器的压缩和解压缩

    >>> a = [1, 2, 3]

    >>> b = ['a', 'b', 'c']

    >>> z = zip(a, b)

    >>> z

    [(1, 'a'), (2, 'b'), (3, 'c')]

    >>> zip(*z)

    [(1, 2, 3), ('a', 'b', 'c')]

    1.12 列表相邻元素压缩器

    >>> a = [1, 2, 3, 4, 5, 6]

    >>> zip(*([iter(a)] * 2))

    [(1, 2), (3, 4), (5, 6)]

    >>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))

    >>> group_adjacent(a, 3)

    [(1, 2, 3), (4, 5, 6)]

    >>> group_adjacent(a, 2)

    [(1, 2), (3, 4), (5, 6)]

    >>> group_adjacent(a, 1)

    [(1,), (2,), (3,), (4,), (5,), (6,)]

    >>> zip(a[::2], a[1::2])

    [(1, 2), (3, 4), (5, 6)]

    >>> zip(a[::3], a[1::3], a[2::3])

    [(1, 2, 3), (4, 5, 6)]

    >>> group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))

    >>> group_adjacent(a, 3)

    [(1, 2, 3), (4, 5, 6)]

    >>> group_adjacent(a, 2)

    [(1, 2), (3, 4), (5, 6)]

    >>> group_adjacent(a, 1)

    [(1,), (2,), (3,), (4,), (5,), (6,)]

    1.13 在列表中用压缩器和迭代器滑动取值窗口

    >>> def n_grams(a, n):

    ... z = [iter(a[i:]) for i in range(n)]

    ... return zip(*z)

    ...

    >>> a = [1, 2, 3, 4, 5, 6]

    >>> n_grams(a, 3)

    [(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]

    >>> n_grams(a, 2)

    [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

    >>> n_grams(a, 4)

    [(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

    1.14 用压缩器反转字典

    >>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

    >>> m.items()

    [('a', 1), ('c', 3), ('b', 2), ('d', 4)]

    >>> zip(m.values(), m.keys())

    [(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]

    >>> mi = dict(zip(m.values(), m.keys()))

    >>> mi

    {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

    1.15 列表展开

    >>> a = [[1, 2], [3, 4], [5, 6]]

    >>> list(itertools.chain.from_iterable(a))

    [1, 2, 3, 4, 5, 6]

    >>> sum(a, [])

    [1, 2, 3, 4, 5, 6]

    >>> [x for l in a for x in l]

    [1, 2, 3, 4, 5, 6]

    >>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

    >>> [x for l1 in a for l2 in l1 for x in l2]

    [1, 2, 3, 4, 5, 6, 7, 8]

    >>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]

    >>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

    >>> flatten(a)

    [1, 2, 3, 4, 5, 6, 7, 8]

    1.16 生成器表达式

    >>> g = (x ** 2 for x in xrange(10))

    >>> next(g)

    0

    >>> next(g)

    1

    >>> next(g)

    4

    >>> next(g)

    9

    >>> sum(x ** 3 for x in xrange(10))

    2025

    >>> sum(x ** 3 for x in xrange(10) if x % 3 == 1)

    408

    1.17 字典推导

    >>> m = {x: x ** 2 for x in range(5)}

    >>> m

    {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

    >>> m = {x: 'A' + str(x) for x in range(10)}

    >>> m

    {0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

    1.18 用字典推导反转字典

    >>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

    >>> m

    {'d': 4, 'a': 1, 'b': 2, 'c': 3}

    >>> {v: k for k, v in m.items()}

    {1: 'a', 2: 'b', 3: 'c', 4: 'd'}

    1.19 命名元组

    >>> Point = collections.namedtuple('Point', ['x', 'y'])

    >>> p = Point(x=1.0, y=2.0)

    >>> p

    Point(x=1.0, y=2.0)

    >>> p.x

    1.0

    >>> p.y

    2.0

    1.20 继承命名元组

    >>> class Point(collections.namedtuple('PointBase', ['x', 'y'])):

    ... __slots__ = ()

    ... def __add__(self, other):

    ... return Point(x=self.x + other.x, y=self.y + other.y)

    ...

    >>> p = Point(x=1.0, y=2.0)

    >>> q = Point(x=2.0, y=3.0)

    >>> p + q

    Point(x=3.0, y=5.0)

    1.21 操作集合

    >>> A = {1, 2, 3, 3}

    >>> A

    set([1, 2, 3])

    >>> B = {3, 4, 5, 6, 7}

    >>> B

    set([3, 4, 5, 6, 7])

    >>> A | B

    set([1, 2, 3, 4, 5, 6, 7])

    >>> A & B

    set([3])

    >>> A - B

    set([1, 2])

    >>> B - A

    set([4, 5, 6, 7])

    >>> A ^ B

    set([1, 2, 4, 5, 6, 7])

    >>> (A ^ B) == ((A - B) | (B - A))

    True

    1.22 操作多重集合

    >>> A = collections.Counter([1, 2, 2])

    >>> B = collections.Counter([2, 2, 3])

    >>> A

    Counter({2: 2, 1: 1})

    >>> B

    Counter({2: 2, 3: 1})

    >>> A | B

    Counter({2: 2, 1: 1, 3: 1})

    >>> A & B

    Counter({2: 2})

    >>> A + B

    Counter({2: 4, 1: 1, 3: 1})

    >>> A - B

    Counter({1: 1})

    >>> B - A

    Counter({3: 1})

    1.23 统计在可迭代器中最常出现的元素

    >>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])

    >>> A

    Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1})

    >>> A.most_common(1)

    [(3, 4)]

    >>> A.most_common(3)

    [(3, 4), (1, 2), (2, 2)]

    1.24 两端都可操作的队列

    >>> Q = collections.deque()

    >>> Q.append(1)

    >>> Q.appendleft(2)

    >>> Q.extend([3, 4])

    >>> Q.extendleft([5, 6])

    >>> Q

    deque([6, 5, 2, 1, 3, 4])

    >>> Q.pop()

    4

    >>> Q.popleft()

    6

    >>> Q

    deque([5, 2, 1, 3])

    >>> Q.rotate(3)

    >>> Q

    deque([2, 1, 3, 5])

    >>> Q.rotate(-3)

    >>> Q

    deque([5, 2, 1, 3])

    1.25 有最大长度的双端队列

    >>> last_three = collections.deque(maxlen=3)

    >>> for i in xrange(10):

    ... last_three.append(i)

    ... print ', '.join(str(x) for x in last_three)

    ...

    0

    0, 1

    0, 1, 2

    1, 2, 3

    2, 3, 4

    3, 4, 5

    4, 5, 6

    5, 6, 7

    6, 7, 8

    7, 8, 9

    1.26 可排序词典

    >>> m = dict((str(x), x) for x in range(10))

    >>> print ', '.join(m.keys())

    1, 0, 3, 2, 5, 4, 7, 6, 9, 8

    >>> m = collections.OrderedDict((str(x), x) for x in range(10))

    >>> print ', '.join(m.keys())

    0, 1, 2, 3, 4, 5, 6, 7, 8, 9

    >>> m = collections.OrderedDict((str(x), x) for x in range(10, 0, -1))

    >>> print ', '.join(m.keys())

    10, 9, 8, 7, 6, 5, 4, 3, 2, 1

    1.27 默认词典

    >>> m = dict()

    >>> m['a']

    Traceback (most recent call last):

    File "", line 1, in

    KeyError: 'a'

    >>>

    >>> m = collections.defaultdict(int)

    >>> m['a']

    0

    >>> m['b']

    0

    >>> m = collections.defaultdict(str)

    >>> m['a']

    ''

    >>> m['b'] += 'a'

    >>> m['b']

    'a'

    >>> m = collections.defaultdict(lambda: '[default value]')

    >>> m['a']

    '[default value]'

    >>> m['b']

    '[default value]'

    1.28 默认字典的简单树状表达

    >>> import json

    >>> tree = lambda: collections.defaultdict(tree)

    >>> root = tree()

    >>> root['menu']['id'] = 'file'

    >>> root['menu']['value'] = 'File'

    >>> root['menu']['menuitems']['new']['value'] = 'New'

    >>> root['menu']['menuitems']['new']['onclick'] = 'new();'

    >>> root['menu']['menuitems']['open']['value'] = 'Open'

    >>> root['menu']['menuitems']['open']['onclick'] = 'open();'

    >>> root['menu']['menuitems']['close']['value'] = 'Close'

    >>> root['menu']['menuitems']['close']['onclick'] = 'close();'

    >>> print json.dumps(root, sort_keys=True, indent=4, separators=(',', ': '))

    {

    "menu": {

    "id": "file",

    "menuitems": {

    "close": {

    "onclick": "close();",

    "value": "Close"

    },

    "new": {

    "onclick": "new();",

    "value": "New"

    },

    "open": {

    "onclick": "open();",

    "value": "Open"

    }

    },

    "value": "File"

    }

    }

    1.29 对象到唯一计数的映射

    >>> import itertools, collections

    >>> value_to_numeric_map = collections.defaultdict(itertools.count().next)

    >>> value_to_numeric_map['a']

    0

    >>> value_to_numeric_map['b']

    1

    >>> value_to_numeric_map['c']

    2

    >>> value_to_numeric_map['a']

    0

    >>> value_to_numeric_map['b']

    1

    1.30 最大和最小的几个列表元素

    >>> a = [random.randint(0, 100) for __ in xrange(100)]

    >>> heapq.nsmallest(5, a)

    [3, 3, 5, 6, 8]

    >>> heapq.nlargest(5, a)

    [100, 100, 99, 98, 98]

    1.31 两个列表的笛卡尔积

    >>> for p in itertools.product([1, 2, 3], [4, 5]):

    (1, 4)

    (1, 5)

    (2, 4)

    (2, 5)

    (3, 4)

    (3, 5)

    >>> for p in itertools.product([0, 1], repeat=4):

    ... print ''.join(str(x) for x in p)

    ...

    0000

    0001

    0010

    0011

    0100

    0101

    0110

    0111

    1000

    1001

    1010

    1011

    1100

    1101

    1110

    1111

    1.32 列表组合和列表元素替代组合

    >>> for c in itertools.combinations([1, 2, 3, 4, 5], 3):

    ... print ''.join(str(x) for x in c)

    ...

    123

    124

    125

    134

    135

    145

    234

    235

    245

    345

    >>> for c in itertools.combinations_with_replacement([1, 2, 3], 2):

    ... print ''.join(str(x) for x in c)

    ...

    11

    12

    13

    22

    23

    33

    1.33 列表元素排列组合

    >>> for p in itertools.permutations([1, 2, 3, 4]):

    ... print ''.join(str(x) for x in p)

    ...

    1234

    1243

    1324

    1342

    1423

    1432

    2134

    2143

    2314

    2341

    2413

    2431

    3124

    3142

    3214

    3241

    3412

    3421

    4123

    4132

    4213

    4231

    4312

    4321

    1.34 可链接迭代器

    >>> a = [1, 2, 3, 4]

    >>> for p in itertools.chain(itertools.combinations(a, 2), itertools.combinations(a, 3)):

    ... print p

    ...

    (1, 2)

    (1, 3)

    (1, 4)

    (2, 3)

    (2, 4)

    (3, 4)

    (1, 2, 3)

    (1, 2, 4)

    (1, 3, 4)

    (2, 3, 4)

    >>> for subset in itertools.chain.from_iterable(itertools.combinations(a, n) for n in range(len(a) + 1))

    ... print subset

    ...

    ()

    (1,)

    (2,)

    (3,)

    (4,)

    (1, 2)

    (1, 3)

    (1, 4)

    (2, 3)

    (2, 4)

    (3, 4)

    (1, 2, 3)

    (1, 2, 4)

    (1, 3, 4)

    (2, 3, 4)

    (1, 2, 3, 4)

    1.35 根据文件指定列类聚

    >>> import itertools

    >>> with open('contactlenses.csv', 'r') as infile:

    ... data = [line.strip().split(',') for line in infile]

    ...

    >>> data = data[1:]

    >>> def print_data(rows):

    ... print ' '.join(' '.join('{: <16}'.format(s) for s in row) for row in rows)

    ...

    >>> print_data(data)

    young myope no reduced none

    young myope no normal soft

    young myope yes reduced none

    young myope yes normal hard

    young hypermetrope no reduced none

    young hypermetrope no normal soft

    young hypermetrope yes reduced none

    young hypermetrope yes normal hard

    pre-presbyopic myope no reduced none

    pre-presbyopic myope no normal soft

    pre-presbyopic myope yes reduced none

    pre-presbyopic myope yes normal hard

    pre-presbyopic hypermetrope no reduced none

    pre-presbyopic hypermetrope no normal soft

    pre-presbyopic hypermetrope yes reduced none

    pre-presbyopic hypermetrope yes normal none

    presbyopic myope no reduced none

    presbyopic myope no normal none

    presbyopic myope yes reduced none

    presbyopic myope yes normal hard

    presbyopic hypermetrope no reduced none

    presbyopic hypermetrope no normal soft

    presbyopic hypermetrope yes reduced none

    presbyopic hypermetrope yes normal none

    >>> data.sort(key=lambda r: r[-1])

    >>> for value, group in itertools.groupby(data, lambda r: r[-1]):

    ... print '-----------'

    ... print 'Group: ' + value

    ... print_data(group)

    ...

    -----------

    Group: hard

    young myope yes normal hard

    young hypermetrope yes normal hard

    pre-presbyopic myope yes normal hard

    presbyopic myope yes normal hard

    -----------

    Group: none

    young myope no reduced none

    young myope yes reduced none

    young hypermetrope no reduced none

    young hypermetrope yes reduced none

    pre-presbyopic myope no reduced none

    pre-presbyopic myope yes reduced none

    pre-presbyopic hypermetrope no reduced none

    pre-presbyopic hypermetrope yes reduced none

    pre-presbyopic hypermetrope yes normal none

    presbyopic myope no reduced none

    presbyopic myope no normal none

    presbyopic myope yes reduced none

    presbyopic hypermetrope no reduced none

    presbyopic hypermetrope yes reduced none

    presbyopic hypermetrope yes normal none

    -----------

    Group: soft

    young myope no normal soft

    young hypermetrope no normal soft

    pre-presbyopic myope no normal soft

    pre-presbyopic hypermetrope no normal soft

    presbyopic hypermetrope no normal soft

    展开全文
  • 30 个 Python 编程实用技巧

    万次阅读 多人点赞 2021-10-03 22:13:12
    今天,我给大家带来了一些基本的 Python 编程技巧。所有这些技巧都可以帮助您减少代码并优化执行。你可以在处理常规任务时轻松地在实时项目中使用它们。 目录 1.就地交换两个数字 2.比较运算符的链接 3.使用三元...

    🌊 作者主页:海拥
    🌊 作者简介:🏆CSDN全栈领域优质创作者、🥇HDZ核心组成员、🥈蝉联C站周榜前十
    🌊 粉丝福利:粉丝群 每周送四本书,每月送各种小礼品(搪瓷杯、抱枕、鼠标垫、马克杯等)

    直接跳到末尾 去评论区领书

    今天,我给大家带来了一些基本的 Python 编程技巧。所有这些技巧都可以帮助您减少代码并优化执行。你可以在处理常规任务时轻松地在实时项目中使用它们。

    目录

    1.就地交换两个数字
    2.比较运算符的链接
    3.使用三元运算符进行条件赋值。
    4.使用多行字符串。
    5.将列表元素存储到新变量中。
    6.打印导入模块的文件路径。
    7.使用交互式“_”运算符。
    8.字典/集合理解。
    9.调试脚本。
    10.设置文件共享。
    11.在 Python 中检查对象。
    12.简化 if 语句。
    13.在运行时检测 Python 版本。
    14.组合多个字符串。
    15.反转 string/list 的四种方法。
    16.玩枚举。
    17.在 Python 中使用枚举。
    18.从函数返回多个值。
    19.使用 splat 运算符解包函数参数。
    20.使用字典来存储 switch。
    21.计算一行中任意数字的阶乘。
    22.查找列表中出现频率最高的值。
    23.重置递归限制。
    24.检查对象的内存使用情况。
    25.使用 slots 减少内存开销。
    26.Lambda 模仿打印功能。
    27.从两个相关序列创建字典。
    28.在线搜索字符串中的多个前缀。
    29.形成一个统一的列表,不使用任何循环。
    30.在 Python 中实现真正的 switch-case 语句。
    文末送书

    技巧1 就地交换两个数字

    Python 提供了一种在一行中进行赋值和交换的直观方式。请参考下面的例子。

    x, y = 10, 20
    print(x, y)
     
    x, y = y, x
    print(x, y)
     
    #1 (10, 20)
    #2 (20, 10)
    

    右边的赋值为一个新的元组播种。而左边的立即将那个(未引用的)元组解包到名称 <a><b>

    分配完成后,新元组将被取消引用并标记为垃圾收集。变量的交换也发生在最终。

    回到目录


    技巧2 比较运算符的链接。

    比较运算符的聚合是另一个有时可以派上用场的技巧。

    n = 10 
    result = 1 < n < 20 
    print(result) 
    
    # True 
    
    result = 1 > n <= 9 
    print(result) 
    
    # False
    

    回到目录


    技巧3 使用三元运算符进行条件赋值。

    三元运算符是 if-else 语句的快捷方式,也称为条件运算符。

    [on_true] if [expression] else [on_false]
    

    以下是一些示例,您可以使用它们使代码紧凑简洁。

    下面的语句与它的意思相同,即“如果 y 为 9,则将 10 分配给 x,否则将 20 分配给 x ”。如果需要,我们可以扩展运算符的链接。

    x = 10 if (y == 9) else 20
    

    同样,我们可以对类对象做同样的事情。

    x = (classA if y == 1 else classB)(param1, param2)
    

    在上面的例子中,classA 和 classB 是两个类,其中一个类构造函数将被调用。

    下面是一个没有的例子。加入评估最小数字的条件。

    def small(a, b, c):
    	return a if a <= b and a <= c else (b if b <= a and b <= c else c)
    	
    print(small(1, 0, 1))
    print(small(1, 2, 2))
    print(small(2, 2, 3))
    print(small(5, 4, 3))
    
    #Output
    #0 #1 #2 #3
    

    我们甚至可以在列表推导式中使用三元运算符。

    [m**2 if m > 10 else m**4 for m in range(50)]
    
    #=> [0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561, 10000, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401]
    

    回到目录


    技巧4 使用多行字符串

    基本方法是使用从 C 语言派生的反斜杠。

    multiStr = "select * from multi_row \
    where row_id < 5"
    print(multiStr)
    
    # select * from multi_row where row_id < 5
    

    另一个技巧是使用三引号。

    multiStr = """select * from multi_row 
    where row_id < 5"""
    print(multiStr)
    
    #select * from multi_row 
    #where row_id < 5
    

    上述方法的共同问题是缺乏适当的缩进。如果我们尝试缩进,它会在字符串中插入空格。

    所以最终的解决方案是将字符串拆分成多行,并将整个字符串括在括号中。

    multiStr= ("select * from multi_row "
    "where row_id < 5 "
    "order by age") 
    print(multiStr)
    
    #select * from multi_row where row_id < 5 order by age
    

    回到目录


    技巧5 将列表元素存储到新变量中

    我们可以使用一个列表来初始化一个 no。的变量。在解压列表时,变量的数量不应超过编号。列表中的元素。

    testList = [1,2,3]
    x, y, z = testList
    
    print(x, y, z)
    
    #-> 1 2 3
    

    回到目录


    技巧6 打印导入模块的文件路径

    如果您想知道代码中导入的模块的绝对位置,请使用以下技巧。

    import threading 
    import socket
    
    print(threading)
    print(socket)
    
    #1- <module 'threading' from '/usr/lib/python2.7/threading.py'>
    #2- <module 'socket' from '/usr/lib/python2.7/socket.py'>
    

    回到目录


    技巧7 使用交互式“_”运算符

    这是一个有用的功能,我们很多人都不知道。

    在 Python 控制台中,每当我们测试表达式或调用函数时,结果都会发送到临时名称 _(下划线)。

    >>> 2 + 1
    3
    >>> _
    3
    >>> print _
    3
    

    “_”引用上次执行的表达式的输出。

    回到目录


    技巧8 字典/集合理解

    就像我们使用列表推导一样,我们也可以使用字典/集合推导。它们易于使用且同样有效。这是一个例子。

    testDict = {i: i * i for i in xrange(10)} 
    testSet = {i * 2 for i in xrange(10)}
    
    print(testSet)
    print(testDict)
    
    #set([0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
    #{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
    

    注意 -两个语句中只有 <:> 的区别。此外,要在 Python3 中运行上述代码,请将 替换为 。

    回到目录


    技巧9 调试脚本

    我们可以在 模块的帮助下在 Python 脚本中设置断点。请按照以下示例进行操作。

    import pdb
    pdb.set_trace()
    

    我们可以在脚本的任何地方指定 <pdb.set_trace()> 并在那里设置断点。这是非常方便的。

    回到目录


    技巧10 设置文件共享

    Python 允许运行 HTTP 服务器,您可以使用它从服务器根目录共享文件。下面是启动服务器的命令。

    Python 2

    python -m SimpleHTTPServer
    

    Python 3

    python3 -m http.server
    

    以上命令将在默认端口 8000 上启动服务器。您还可以通过将自定义端口作为最后一个参数传递给上述命令来使用自定义端口。

    回到目录


    技巧11 在 Python 中检查对象

    我们可以通过调用 dir() 方法来检查 Python 中的对象。这是一个简单的例子。

    test = [1, 3, 5, 7]
    print( dir(test) )
    
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    

    回到目录


    技巧12 简化 if 语句

    要验证多个值,我们可以通过以下方式进行。

    if m in [1,3,5,7]:
    

    代替:

    if m==1 or m==3 or m==5 or m==7:
    

    或者,我们可以使用 ‘{1,3,5,7}’ 而不是 ‘[1,3,5,7]’ 作为 ‘in’ 运算符,因为 ‘set’ 可以通过 O(1) 访问每个元素。

    回到目录


    技巧13 在运行时检测 Python 版本

    有时,如果当前运行的 Python 引擎低于支持的版本,我们可能不想执行我们的程序。为此,您可以使用以下代码片段。它还以可读格式打印当前使用的 Python 版本。

    import sys
    
    #Detect the Python version currently in use.
    if not hasattr(sys, "hexversion") or sys.hexversion != 50660080:
        print("Sorry, you aren't running on Python 3.5\n")
        print("Please upgrade to 3.5.\n")
        sys.exit(1)
        
    #Print Python version in a readable format.
    print("Current Python version: ", sys.version)
    

    或者,您可以在上面的代码中使用sys.version_info >= (3, 5)替换sys.hexversion!= 50660080。这是一位知情读者的建议。

    在 Python 2.7 上运行时的输出。

    Python 2.7.10 (default, Jul 14 2015, 19:46:27)
    [GCC 4.8.2] on linux
       
    Sorry, you aren't running on Python 3.5
    
    Please upgrade to 3.5.
    

    在 Python 3.5 上运行时的输出。

    Python 3.5.1 (default, Dec 2015, 13:05:11)
    [GCC 4.8.2] on linux
       
    Current Python version:  3.5.2 (default, Aug 22 2016, 21:11:05) 
    [GCC 5.3.0]
    

    回到目录


    技巧14 组合多个字符串

    如果您想连接列表中所有可用的标记,请参见以下示例。

    >>> test = ['I', 'Like', 'Python', 'automation']
    

    现在,让我们从上面给出的列表中的元素创建一个字符串。

    >>> print ''.join(test)
    

    回到目录


    技巧15 反转 string/list 的四种方法

    反转列表本身

    testList = [1, 3, 5]
    testList.reverse()
    print(testList)
    
    #-> [5, 3, 1]
    

    在循环中迭代时反转

    for element in reversed([1,3,5]): print(element)
    
    #1-> 5
    #2-> 3
    #3-> 1
    

    反转一个字符串

    "Test Python"[::-1]
    

    这使输出为“nohtyP tseT”

    使用切片反转列表

    [1, 3, 5][::-1]
    

    上面的命令将输出 [5, 3, 1]。

    回到目录


    技巧16 玩枚举

    使用枚举器,在循环中很容易找到索引。

    testlist = [10, 20, 30]
    for i, value in enumerate(testlist):
    	print(i, ': ', value)
    
    #1-> 0 : 10
    #2-> 1 : 20
    #3-> 2 : 30
    

    回到目录


    技巧17 在 Python 中使用枚举。

    我们可以使用以下方法来创建枚举定义。

    class Shapes:
    	Circle, Square, Triangle, Quadrangle = range(4)
    
    print(Shapes.Circle)
    print(Shapes.Square)
    print(Shapes.Triangle)
    print(Shapes.Quadrangle)
    
    #1-> 0
    #2-> 1
    #3-> 2
    #4-> 3
    

    回到目录


    技巧18 从函数返回多个值。

    支持此功能的编程语言并不多。但是,Python 中的函数确实会返回多个值。

    请参考以下示例以查看它的工作情况。

    # function returning multiple values.
    def x():
    	return 1, 2, 3, 4
    
    # Calling the above function.
    a, b, c, d = x()
    
    print(a, b, c, d)
    

    #-> 1 2 3 4

    回到目录


    技巧19 使用 splat 运算符解包函数参数。

    splat 运算符提供了一种解压参数列表的艺术方式。为清楚起见,请参阅以下示例。

    def test(x, y, z):
    	print(x, y, z)
    
    testDict = {'x': 1, 'y': 2, 'z': 3} 
    testList = [10, 20, 30]
    
    test(*testDict)
    test(**testDict)
    test(*testList)
    
    #1-> x y z
    #2-> 1 2 3
    #3-> 10 20 30
    

    回到目录


    技巧20 使用字典来存储 switch。

    我们可以制作一个字典存储表达式。

    stdcalc = {
    	'sum': lambda x, y: x + y,
    	'subtract': lambda x, y: x - y
    }
    
    print(stdcalc['sum'](9,3))
    print(stdcalc['subtract'](9,3))
    
    #1-> 12
    #2-> 6
    

    回到目录


    技巧21 计算一行中任意数字的阶乘。

    Python 2.x.

    result = (lambda k: reduce(int.__mul__, range(1,k+1),1))(3)
    print(result)
    #-> 6
    

    Python 3.x.

    import functools
    result = (lambda k: functools.reduce(int.__mul__, range(1,k+1),1))(3)
    print(result)
    

    #-> 6
    回到目录


    技巧22 查找列表中出现频率最高的值。

    test = [1,2,3,4,2,2,3,1,4,4,4]
    print(max(set(test), key=test.count))
    
    #-> 4
    

    回到目录


    技巧23 重置递归限制。

    Python 将递归限制限制为 1000。我们可以重置它的值。

    import sys
    
    x=1001
    print(sys.getrecursionlimit())
    
    sys.setrecursionlimit(x)
    print(sys.getrecursionlimit())
    
    #1-> 1000
    #2-> 1001
    

    请仅在需要时应用上述技巧。

    回到目录


    技巧24 检查对象的内存使用情况。

    在 Python 2.7 中,32 位整数消耗 24 字节,而在 Python 3.5 中使用 28 字节。为了验证内存使用情况,我们可以调用 方法。

    Python 2.7.

    import sys
    x=1
    print(sys.getsizeof(x))
    
    #-> 24
    

    Python 3.5.

    import sys
    x=1
    print(sys.getsizeof(x))
    
    #-> 28
    

    回到目录


    技巧25 使用 __slots__ 减少内存开销。

    你有没有观察到你的 Python 应用程序消耗了大量资源,尤其是内存?这是使用<__slots__>类变量在一定程度上减少内存开销的一种技巧。

    import sys
    class FileSystem(object):
    
    	def __init__(self, files, folders, devices):
    		self.files = files
    		self.folders = folders
    		self.devices = devices
    
    print(sys.getsizeof( FileSystem ))
    
    class FileSystem1(object):
    
    	__slots__ = ['files', 'folders', 'devices']
    	
    	def __init__(self, files, folders, devices):
    		self.files = files
    		self.folders = folders
    		self.devices = devices
    
    print(sys.getsizeof( FileSystem1 ))
    
    #In Python 3.5
    #1-> 1016
    #2-> 888
    

    显然,您可以从结果中看到内存使用量有所节省。但是当一个类的内存开销不必要地大时,你应该使用 __slots__ 。仅在分析应用程序后执行此操作。否则,您将使代码难以更改并且没有真正的好处。

    回到目录


    技巧26 Lambda 模仿打印功能。

    import sys
    lprint=lambda *args:sys.stdout.write(" ".join(map(str,args)))
    lprint("python", "tips",1000,1001)
    
    #-> python tips 1000 1001
    

    回到目录


    技巧27 从两个相关序列创建字典。

    t1 = (1, 2, 3)
    t2 = (10, 20, 30)
    
    print(dict (zip(t1,t2)))
    
    #-> {1: 10, 2: 20, 3: 30}
    

    回到目录


    技巧28 在线搜索字符串中的多个前缀。

    print("http://www.baidu.com".startswith(("http://", "https://")))
    print("https://juejin.cn".endswith((".com", ".cn")))
    
    #1-> True
    #2-> True
    

    回到目录


    技巧29 形成一个统一的列表,不使用任何循环。

    import itertools
    test = [[-1, -2], [30, 40], [25, 35]]
    print(list(itertools.chain.from_iterable(test)))
    
    #-> [-1, -2, 30, 40, 25, 35]
    

    如果您有一个包含嵌套列表或元组作为元素的输入列表,请使用以下技巧。但是,这里的限制是它使用了 for 循环。

    def unifylist(l_input, l_target):
        for it in l_input:
            if isinstance(it, list):
                unifylist(it, l_target)
            elif isinstance(it, tuple):
                unifylist(list(it), l_target)
            else:
                l_target.append(it)
        return l_target
    
    test =  [[-1, -2], [1,2,3, [4,(5,[6,7])]], (30, 40), [25, 35]]
    
    print(unifylist(test,[]))
    
    #Output => [-1, -2, 1, 2, 3, 4, 5, 6, 7, 30, 40, 25, 35]
    

    统一包含列表和元组的列表的另一种更简单的方法是使用 Python 的 < more_itertools > 包。它不需要循环。只需执行 < pip install more_itertools >,如果还没有的话。

    import more_itertools
    
    test = [[-1, -2], [1, 2, 3, [4, (5, [6, 7])]], (30, 40), [25, 35]]
    
    print(list(more_itertools.collapse(test)))
    
    #Output=> [-1, -2, 1, 2, 3, 4, 5, 6, 7, 30, 40, 25, 35]
    

    回到目录


    技巧30 在 Python 中实现真正的 switch-case 语句。

    这是使用字典来模仿 switch-case 构造的代码。

    def xswitch(x): 
    	return xswitch._system_dict.get(x, None) 
    
    xswitch._system_dict = {'files': 10, 'folders': 5, 'devices': 2}
    
    print(xswitch('default'))
    print(xswitch('devices'))
    
    #1-> None
    #2-> 2
    

    回到目录


    🥇 评论区抽粉丝送书啦

    💌 欢迎大家在评论区提出意见和建议!(抽两位幸运儿送书,实物图如下)💌

    在这里插入图片描述

    《Python 入门到人工智能实战》

    【内容简介】

    《Python 入门到人工智能实战》是针对零基础编程学习者编写的教程。从初学者角度出发,每章以问题为导向,辅以大量的实例,详细地介绍了Python 基础、机器学习,以及最好也最易学习的两个平台PyTorch 和Keras。
      全书共20 章,包括Python 安装配置、Python 语言基础、流程控制语句、序列、函数、对象、文件及异常处理、数据处理和分析的重要模块(NumPy、Pandas)、机器学习基础、机器学习常用调优方法、神经网络、卷积神经网络,以及使用PyTorch、Keras 实现多个人工智能实战案例等。书中所有知识都结合具体实例进行讲解,涉及的程序代码给出了详细的注释,使读者可以轻松领会。

    也有不想靠抽,想自己买的同学可以参考下面的链接

    京东自营购买链接:

    《Python入门到人工智能实战》(吴茂贵,等) - 京东图书

    当当自营购买链接:

    《Python入门到人工智能实战》(吴茂贵,等) - 当当图书

    📣 注意:

    大家点赞关注,三天后也就是 10月6日 从评论区留言的同学中抽取两位送书

    🌊 面试题库:Java、Python、前端核心知识点大全和面试真题资料
    🌊 电子图书:图灵程序丛书 300本、机械工业出版社6000册免费正版图书
    🌊 办公用品:精品PPT模板几千套,简历模板一千多套
    🌊 学习资料:2300套PHP建站源码,微信小程序入门资料

    如果中奖了联系不上则视为放弃,可以从下方公众号里找到作者的联系方式,每周都会送四本书,后面送书力度还会加大,一年送几百上千本不是问题,回复【进群】领书不迷路,群内 每位成员 我都会送一本。回复【资源】可获取上面的资料👇🏻👇🏻👇🏻

    展开全文
  • python编程小技巧-切换工作目录到指定目录 很多经常用python编程的小伙伴,可能就会对于python目录环境感到麻烦,有些代码依赖的数据不再当前工作目录的话,就需要些大量路径代码指定,事实上,我们根本不需要这么...

    python编程小技巧-切换工作目录到指定目录

    很多经常用python编程的小伙伴,可能就会对于python目录环境感到麻烦,有些代码依赖的数据不再当前工作目录的话,就需要些大量路径代码指定,事实上,我们根本不需要这么麻烦

    os库提供了两个很好的函数,getced()和chidr(),前者可以查看当前工作目录,后者可以切换当前的工作目录到指定目录,如果可以正确使用,可以省去很多配置路径的工作。
    如下是一个示例代码:

    
    import os
    
    print(os.getcwd())
    
    os.chdir(r"E:\bigdata")
    
    print(os.getcwd())
    print(os.listdir(os.getcwd()))
    os.system("pause")
    

    结果如下,我们成功切换了工作目录
    在这里插入图片描述

    展开全文
  • python中也能通过借助yield的方式来实现一个迭代器。yield有一个关键的作能,它能够中断当前的执行逻辑,保持住现场(各种值的状态,执行的位置等等),返回相应的值,下一次执行的时候能够无缝的接着上次的地方...
  • 这篇文章主要介绍了Python中的Null模式与桥接模式编程,Null模式与桥接模式都属于Python的设计模式编程,需要的朋友可以参考下 Null模式 我想每个人都有一种经历,为了获取某属性,但是有时候属性是None,那么需要你做...
  • Python初学者的一些编程技巧

    千次阅读 多人点赞 2020-02-10 21:59:40
    这篇文章主要介绍了给Python初学者的一些编程技巧,皆是基于基础的一些编程习惯建议,需要的朋友可以参考下 交换变量 x = 6 y = 5 x, y = y, x print x >>> 5 print y >>> 6 if 语句在行内 ...
  • 本文为你介绍Pandas隐藏的炫酷小技巧,我相信这些会对你有所帮助。 或许本文中的某些命令你早已知晓,只是没意识到它还有这种打开方式。 Pandas是一个在Python中广泛应用的数据分析包。市面上有很多关于Pandas的...
  • Python 除法小技巧

    2021-01-20 05:02:20
    您可能感兴趣的文章:Python中比较特别的除法运算和幂运算介绍低版本中Python除法运算小技巧跟老齐学Python之啰嗦的除法Python对小数进行除法运算的正确方法示例Python中除法使用的注意事项简单介绍Python中的floor...
  • Python最大的优点之一就是语法简洁,好的代码就像伪代码一样,干净、整洁、一目了然。这篇文章给大家介绍Python 优雅编程技巧,感兴趣的朋友跟随编一起看看吧
  • 在用jupyter notebook写python代码的过程中会产生很多变量,而关闭后或者restart jupyter kernel后所有变量均会消失,想要查看变量就必须将代码重新再运行一遍,而想在另一个jupyter notebook中调用变量就更加麻烦。...
  • python 代码中可以看到一些常见的 trick,在这里做一个简单的结。 json 字符串格式化 在开发 web 应用的时候经常会用到 json 字符串,但是一段比较长的 json 字符串是可读性较差的,不容易看出来里面结构的。 ...
  • python编程更加丝滑的一些小技巧

    千次阅读 2020-09-30 00:38:08
    文章目录10个python编程小技巧字符串逆序将序列内容赋值给多个变量itertools自适应UnpackingEnumerateSlice类对列表的相邻元素进行分组使用next()来迭代生成器CounterDequeue结语 10个python编程小技巧   ...
  • 码代码时,有时候需要根据比较大小分别赋值: import random seq = [random.randint(0, 1000) for _ in range(100)] #方法1: xmax, xmin = max(seq), min(seq) #方法2: xmax, *_, xmin = sorted(seq) ...
  • 编程过程中,我们往往会遇到一个麻烦——微软 Windows 系统在文件夹名之间使用反斜杠字符,而几乎所有其它的计算机(操作系统)都使用正斜杠: 这是由于上世纪 80 年代早期计算机历史上的一个意外。「MS-...
  • 特别是linux系统,装了多个python,有时候找不到python的绝对路径,有时候装了个django,又找不到django安装到哪里了。。当然查看的方法有很多种,这里列出几种,供没有经验的人参考下。 复制代码 代码如下: G:\code...
  • 这篇文章主要介绍了Python简单基础程序的实例代码,非常不错,具有一定的参考借鉴价值 ,需要的朋友可以参考下 1 九九乘法表 for i in range(9):#从0循环到8 i += 1#等价于 i = i+1 for j in range(i):#从0循环到...
  • Python编程的若干个经典小技巧

    千次阅读 2021-01-11 19:08:14
    1. 原地交换两个数字Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例:x,y= 10,20print(x,y)x,y= y,xprint(x,y)#1 (10, 20)#2 (20, 10)赋值的右侧形成了一个新的元组,左侧立即解析...
  • python的30个编程技巧

    千次阅读 2017-12-02 16:30:37
    从公众号上看到了一篇文章《30个python编程技巧!》,觉得有些挺有用的,有的也一直在用,就挨个实现了一下。  1、原地交换两个数字 In [1]: x, y =10, 20 print(x, y) y, x = x, ...
  • 如何设计与构建自己的fuzzing工具,如何利用fuzzing测试来找出存在于软件产品中的安全漏洞,一些小技巧诸如钩子与注入技术的应用,以及对一些主流Python安全工具如PyDbg、Immunity Debugger、Sulley、IDAPython、...
  • python实用30个小技巧

    千次阅读 2019-06-16 15:01:40
    Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例: In [1]: x,y = 10 ,20 In [2]: print(x,y) 10 20 In [3]: x, y = y, x In [4]: print(x,y) 20 10 赋值的右侧形成了一...
  • 送给python初学者在简单编程练习题中的小技巧

    万次阅读 多人点赞 2018-06-18 03:48:29
    一些python的初学者,尤其是由别的语言入门的,比如c语言,在面对python学习时,在一些编程思路上的思维还没有转变好,下面是一些适用于初学者用python进行一些简单编程练习题的小技巧 输入 由空格分隔的一行...
  • 【1】详细讲解鼎鼎大名的Python编程神器Jupyter Notebook。 【2】Jupyter Notebook看似简单,实际上功能非常强大,而且有很多实用的小技巧。 【3】遗憾的是,目前市面上还没有一个详细讲解Jupyter Notebook的视频...
  • Python一直被赞誉为最容易学的编程语言。今天为大家推荐几个很不错的学习资源,希望大家喜欢~( *︾▽︾)如果你的Python开发之旅有一段时间了,这门课程可能是一个很好的开始。Python for Beginners课程是由Alex ...
  • 一、Python与量化金融在量化投资领域,获取数据、整理数据、模型计算、数据图形化均可以用python实现;而且Python强大的库功能使其非常适合做quant类工作的语言,进而逐渐成为科学计算方面的统治级语言;IPython,...
  • 今天,项目经理问我一个问题,问我这里有2000个URL要检查是否能正常打开,其实我是拒绝的,我知道因为要写代码了,正好学了点Python,一想,python处理起来容易,就选了python,开始把思路想好: 1.首先2000个URL。...
  • python在线编程平台-python在线编程

    千次阅读 2020-10-30 00:06:03
    python并发编程的思维导图,原始文件请转到:processon链接查看 ? io模型阻塞io ? 非阻塞io ? io多路复用 ? 事件驱动io ? 异步io ?...本节课我们来学习一下python的模块编程模块是一个包含所有你定义的函数和变量的...
  • Python高效编程技巧

    千次阅读 2020-12-21 19:42:10
    作者 l jerryning来源 l Python编程与实战工作中经常要处理各种各样的数据,遇到项目赶进度的时候自己写函数容易浪费时间。Python 中有很多内置函数帮你提高工作效率!一:根据条件在序列中筛选数据1.假设有一个...
  • Python如今无疑是全球最受欢迎的编程语言。它最大的好处,就是让越来越多的人通过它加入了编程的世界。近年来,Python的使用人数与日俱增,超过了包括JavaScript在内的其他计算机语言许多人学习Python是为了探索它...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 51,141
精华内容 20,456
关键字:

python编程小技巧

python 订阅