Python lernen: 17 Tipps zu Python

Python ist eine sehr prägnante Sprache Pythons ist so prägnant und einfach zu verwenden, dass man über die Portabilität dieser Sprache staunen muss. In diesem Artikel listen wir 17 sehr nützliche Python-Tipps auf. Diese 17 Tipps sind sehr einfach, werden aber häufig verwendet und können zu verschiedenen Ideen inspirieren. 🎜> Bringen Sie Ihre Ideen und Kreativität ganz einfach zum Ausdruck. Tatsächlich ist der Hauptgrund, warum sich viele Menschen dafür entscheiden,

Python

zu lernen, die Schönheit seiner Programmierung, die es sehr natürlich macht, zu programmieren und Ideen auszudrücken. Darüber hinaus kann Python auf viele Arten geschrieben werden. Datenwissenschaft, Webentwicklung und maschinelles Lernen können alle Python nutzen. Quora, Pinterest und Spotify verwenden alle Python als Backend-Entwicklungssprache. Variablenwerte tauschen

"""pythonic way of value swapping"""
a, b=5,10
print(a,b)
a,b=b,a
print(a,b)

Werte tauschen ​​in der Liste werden alle Elemente zu einer Zeichenfolge zusammengefasst

a=["python","is","awesome"]
print("  ".join(a))

Finden Sie den Wert mit der höchsten Häufigkeit
in der Liste

"""most frequent element in a list"""
a=[1,2,3,1,2,3,2,2,4,5,1]
print(max(set(a),key=a.count))
"""using Counter from collections"""
from collections import Counter
cnt=Counter(a)
print(cnt.most_commin(3))

Überprüfen Sie, ob zwei Zeichenfolgen aus denselben Buchstaben in unterschiedlicher Reihenfolge bestehen

from collections import Counter
Counter(str1)==Counter(str2)

Umgekehrte Zeichenfolge

"""reversing string with special case of slice step param"""
  a ='abcdefghij k lmnopqrs tuvwxyz 'print(a[ ::-1] )
  """iterating over string contents in reverse efficiently."""
  for char in reversed(a):
  print(char )
  """reversing an integer through type conversion and slicing ."""
  num = 123456789
  print( int( str(num)[::1]))

Liste umkehren

 """reversing list with special case of slice step param"""
  a=[5,4,3,2,1]
  print(a[::1])
  """iterating over list contents in reverse efficiently ."""
  for ele in reversed(a):
  print(ele )

Transponiertes zweidimensionales Array

"""transpose 2d array [[a,b], [c,d], [e,f]] -> [[a,c,e], [b,d,f]]"""
original = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip( *original )
print(list( transposed) )

Kettenvergleich

""" chained comparison with all kind of operators"""
b  =6
print(4< b < 7 )
print(1 == b < 20)

Kettenfunktionsaufruf

"""calling different functions with same arguments based on condition"""
def  product(a, b):    
    return a * b
def  add(a, b):   
    return a+ b
b =True
print((product if b else add)(5, 7))

Liste kopieren

 """a fast way to make a shallow copy of a list"""
  b=a
  b[0]= 10
 """ bothaandbwillbe[10,2,3,4,5]"""
 b = a[:]b[O] = 10
  """only b will change to [10, 2, 3, 4, 5] """
  """copy list by typecasting method"""
  a=[l,2,3,4,5]
print(list(a))
  """using the list.copy( ) method ( python3 only )""" 
  a=[1,2,3,4,5]
  print(a.copy( ))
  """copy nested lists using copy. deepcopy"""
  from copy import deepcopy
  l=[l,2],[3,4]]
  l2 = deepcopy(l)
print(l2)

Wörterbuch-Get-Methode

""" returning None or default value, when key is not in dict""" 
d = ['a': 1, 'b': 2]
print(d.get('c', 3))

Wörterbuchelemente nach „Schlüssel“ sortieren

"""Sort a dictionary by its values with the built-in sorted( ) function and a ' key' argument ."""
  d = {'apple': 10, 'orange': 20, ' banana': 5, 'rotten tomato': 1)
   print( sorted(d. items( ), key=lambda x: x[1]))
  """Sort using operator . itemgetter as the sort key instead of a lambda"""
  from operator import itemgetter
  print( sorted(d. items(), key=itemgetter(1)))
  """Sort dict keys by value"""
  print( sorted(d, key=d.get))

Für sonst

"""else gets called when for loop does not reach break statement"""
a=[1,2,3,4,5]
for el in a: 
 if el==0: 
  break
else: 
 print( 'did not break out of for  loop' )

Konvertieren Sie die Liste in ein durch Kommas getrenntes Format

  """converts list to comma separated string"""
items = [foo', 'bar', 'xyz']
print (','.join( items))
"""list of numbers to comma separated"""
numbers = [2, 3, 5, 10]
print (','.join(map(str, numbers)))
"""list of mix data"""
data = [2, 'hello', 3, 3,4]
print (','.join(map(str, data)))

Wörterbuch zusammenführen

"""merge dict's"""
d1 = {'a': 1}
d2 = {'b': 2}
# python 3.5 
print({**d1, **d2})
print(dict(d1. items( ) | d2. items( )))
d1. update(d2)
print(d1)

Minimal- und Maximalwerte ​​im Listenindex

"""Find Index of Min/Max Element .
"""
lst= [40, 10, 20, 30]
def minIndex(lst): 
  return min( range(len(lst)), key=lst.. getitem__ )
def maxIndex(lst):
  return max( range( len(lst)), key=lst.. getitem__ )
print( minIndex(lst)) 
print( maxIndex(lst))

Doppelte Elemente in der Liste entfernen

  """remove duplicate items from list. note: does, not preserve the original list order"""
items=[2,2,3,3,1]
newitems2 = list(set( items)) 
print (newitems2)
"""remove dups and, keep. order"""
from collections import OrderedDict
items = ["foo", "bar", "bar", "foo"]
print( list( orderedDict.f romkeys(items ).keys( )))

Oben geht es um 17 praktische und effektive kleine Operationen in der Python-Programmierung

Das obige ist der detaillierte Inhalt vonPython lernen: 17 Tipps zu Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!