Python Basics. 1 of 7 9/5/2018, 8:51 AM. txt1 = "ada lovelace, english mathematician and writer" print(txt1)

Size: px

Start display at page:

Download "Python Basics. 1 of 7 9/5/2018, 8:51 AM. txt1 = "ada lovelace, english mathematician and writer" print(txt1)"

Horatio Glenn
5 years ago
Views:

1 1 of 7 9/5/2018, 8:51 AM Python Basics In [1]: txt1 = "ada lovelace, english mathematician and writer" print(txt1) ada lovelace, english mathematician and writer Here txt1 is a variable and "ada lovelace, english mathematician and writer" is a string. The rules for naming variables are: Variable names can only contain letters, numbers, and underscores. They can not start with a number. Spaces are not allowed in variable names. Do not use Python keywords and (built-in) function names as variable names. Examples: Good: message1, text_1, first_name, string1, length_of_txt1, _1txt. Bad/Wrong: 1message, str, text 1, global, 1txt. In [2]: # To obtain the keywords for your version of Python (e.g., 3.5) import keyword print(keyword.kwlist) print(len(keyword.kwlist)) ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', ' def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'retur n', 'try', 'while', 'with', 'yield'] 33

2 2 of 7 9/5/2018, 8:51 AM In [3]: # Examples of built-in functions print(len(txt1)) # length of string in txt1 print(hex(ord('a'))) # converting ascii character to decimal to hex print(chr(97)) # lowercase(a) is hex 61 = decimal 97 print(chr(int('6d',16))) # converting hex to decimal to ascii character 46 0x41 a m Simple Object Types None (null object) Boolean (True, False) Integer Float Complex String

3 3 of 7 9/5/2018, 8:51 AM In [4]: n1 = 91 n2 = n3 = float(n1) n4 = int(n2) n5 = round(n2) print('n1={}, type(n1)={}'.format(n1,type(n1))) print('n2={}, type(n2)={}'.format(n2,type(n2))) uments to include print('n3={}, type(n3)={}'.format(n3,type(n3))) print('n4={}, type(n4)={}'.format(n4,type(n4))) print('n5={}, type(n5)={}'.format(n5,type(n5))) # formatting print output # {} are placeholders for the arg n1=91, type(n1)=<class 'int'> n2= , type(n2)=<class 'float'> n3=91.0, type(n3)=<class 'float'> n4=2, type(n4)=<class 'int'> n5=3, type(n5)=<class 'int'> In [5]: n6 = complex(1,2) print('n6={}, type(n6)={}'.format(n6,type(n6))) print('n6*={}, type(n6*)={}'.format(n6.conjugate(),type(n6.conjugate()))) ate is a method print('re[n6]={}, type(re[n6]={})'.format(n6.real,type(n6.real))) s a property print('im[n6]={}, type(im[n6]={})'.format(n6.imag,type(n6.imag))) s a property print('abs(n6)={}, type(abs(n6)={})'.format(abs(n6),type(abs(n6)))) n6=(1+2j), type(n6)=<class 'complex'> n6*=(1-2j), type(n6*)=<class 'complex'> Re[n6]=1.0, type(re[n6]=<class 'float'>) Im[n6]=2.0, type(im[n6]=<class 'float'>) abs(n6)= , type(abs(n6)=<class 'float'>) # conjug # real i # imag i In [6]: n0 = None print('n0={}, type(n0)={}'.format(n0,type(n0))) print('n1==n2: {}, type(n1==n2)={}'.format(n1==n2,type(n1==n2))) print('n1!=n0: {}, type(n1!=n0)={}'.format(n1!=n0,type(n1!=n0))) print('n1==n1*: {}, type(n1==n1*)={}'.format(n1==n1.conjugate(),type(n1==n1.conjuga te()))) print('n6==n6*: {}, type(n6==n6*)={}'.format(n6==n6.conjugate(),type(n6==n6.conjuga te()))) n0=none, type(n0)=<class 'NoneType'> n1==n2: False, type(n1==n2)=<class 'bool'> n1!=n0: True, type(n1!=n0)=<class 'bool'> n1==n1*: True, type(n1==n1*)=<class 'bool'> n6==n6*: False, type(n6==n6*)=<class 'bool'> In [7]: Out[7]: n0 = None type(n0) NoneType Strings are sequences of characters inside a pair of single (') or double (") quotes. One of the simplest things one can do with strings is to change the case of the words in a string using the upper(), lower(), or title() methods. A method is an action that can be performed on some data, for instance 'A'.lower() yields a. Methods are followed by parentheses because they often need additional parameters. In general arithmetic operations are not defined for strings, but strings can be concatenated using the + operator.

4 4 of 7 9/5/2018, 8:51 AM In [8]: print('a'.lower()) print(txt1.upper()) print(txt1.title()) txt2 = "is considered to be the first computer programmer." print(txt1 + ', ' + txt2) # string concatenation a ADA LOVELACE, ENGLISH MATHEMATICIAN AND WRITER Ada Lovelace, English Mathematician And Writer ada lovelace, english mathematician and writer, is considered to be the first co mputer programmer. In [9]: txt3 = "Ada Lovelace's" + ' mother was called "The Princess of Parallelograms"' print(txt3) # using both single and double quotes in strings Ada Lovelace's mother was called "The Princess of Parallelograms" Jupyter Notebooks are quite versatile. They can have "Markdown" cells with html, LaTeX (, ) and images: In [10]: # Accessing individual characters in strings # Indexing starts at 0 txt4 = txt3[0] + txt3[8] + txt3[9] + txt3[13] print(txt4) print(type(txt4)) Alas <class 'str'> More general built-in object types in Python that can contain sequences or collections of data are tuples, lists, sets, and dictionaries. The values in a list are called elements or items. They can be of any type, including lists (called nested lists). The elements in a list can change throughout the life of a program. Tuples are very similar to lists, but they are immutable, that is, once defined the elements in the tuples can be accessed, but not altered. A set in Python is a data structure that is equivalent to sets in mathematics. It can contain any immutable data type like numbers, strings or tuples as elements and the elements themselves are mutable, but each specific element occurs only once. Dictionaries can store an almost limitless amount of easily retrievable information in the form of key-value pairs. A key-value pair is a set of values associated with each other. When a key is provided, Python returns the value associated with that key. Dictionaries are dynamic structures and key-value pairs can be added, modified, or deleted at any time.

5 5 of 7 9/5/2018, 8:51 AM In [11]: # Example lists L0 = [] # empty list L1 = [1, 2, 4, 8, 16, 32, 64, 128] # numeric list L2 = list(range(5)) # range: from 0 up to but not including 5 L3 = [1, 'two', [3, 4]] # mixed elements print('l0={}, type(l0)={}'.format(l0,type(l0))) print('l1={}, type(l1)={}'.format(l1,type(l1))) print('l2={}, type(l2)={}'.format(l2,type(l2))) print('l3={}, type(l3)={}'.format(l3,type(l3))) L0=[], type(l0)=<class 'list'> L1=[1, 2, 4, 8, 16, 32, 64, 128], type(l1)=<class 'list'> L2=[0, 1, 2, 3, 4], type(l2)=<class 'list'> L3=[1, 'two', [3, 4]], type(l3)=<class 'list'> In [12]: # Accessing list elements L1a = L1[4] L1b = L1[5:8] # subset of list L2a = L2[-1] # last element in list L3a = L3[1] L3b = L3[2][0] # first element in nested list print('l1a={}, type(l1a)={}'.format(l1a,type(l1a))) print('l1b={}, type(l1b)={}'.format(l1b,type(l1b))) print('l2a={}, type(l2a)={}'.format(l2a,type(l2a))) print('l3a={}, type(l3a)={}'.format(l3a,type(l3a))) print('l3b={}, type(l3b)={}'.format(l3b,type(l3b))) L1a=16, type(l1a)=<class 'int'> L1b=[32, 64, 128], type(l1b)=<class 'list'> L2a=4, type(l2a)=<class 'int'> L3a=two, type(l3a)=<class 'str'> L3b=3, type(l3b)=<class 'int'> In [13]: # Cloning/copying a list L4 = list(range(5)) L5 = L4 # only one list, but with two names L5.extend([11,12]) L6 = list(range(5)) L7 = L6.copy() # L6 and L7 are two separate lists L7.extend([11,12]) print('l4={}'.format(l4)) print('l5={}'.format(l5)) print('l6={}'.format(l6)) print('l7={}'.format(l7)) L4=[0, 1, 2, 3, 4, 11, 12] L5=[0, 1, 2, 3, 4, 11, 12] L6=[0, 1, 2, 3, 4] L7=[0, 1, 2, 3, 4, 11, 12] In [14]: # Example tuples T1 = ('alpha', 'beta', 'delta', 'delta') T2 = ([ , ], 'e', 'pi', -1, -2) print('t1={}, type(t1)={}'.format(t1,type(t1))) print('t2={}, type(t2)={}'.format(t2,type(t2))) T1=('alpha', 'beta', 'delta', 'delta'), type(t1)=<class 'tuple'> T2=([ , ], 'e', 'pi', -1, -2), type(t2)=<class 'tuple'>

6 6 of 7 9/5/2018, 8:51 AM In [15]: # Tuples are immutable, but not lists nested in tuples #T1[2] = 'gamma' # TypeError: 'tuple' object does not support item assignment T2[0][0] = -2.7 # but this works print(t2) ([-2.7, ], 'e', 'pi', -1, -2) In [16]: # Example sets S1 = {1,2,3,2,1} S2 = set('ada Lovelace') S3 = set((2,3,5,('am','pm'),(2,3,5,7,11),2,3,5,7,11,('am','pm'))) print('s1={}, type(s1)={}'.format(s1,type(s1))) print('s2={}, type(s2)={}'.format(s2,type(s2))) print('s3={}, type(s3)={}'.format(s3,type(s3))) S1={1, 2, 3}, type(s1)=<class 'set'> S2={'d', 'c', 'L', 'e', ' ', 'a', 'l', 'o', 'A', 'v'}, type(s2)=<class 'set'> S3={2, 3, 5, 7, 11, ('am', 'pm'), (2, 3, 5, 7, 11)}, type(s3)=<class 'set'> In [17]: # Add/remove an element from a set S1.add(99) S3.remove(('am','pm')) print('s1={}, type(s1)={}'.format(s1,type(s1))) print('s3={}, type(s3)={}'.format(s3,type(s3))) S1={99, 1, 2, 3}, type(s1)=<class 'set'> S3={2, 3, 5, 7, 11, (2, 3, 5, 7, 11)}, type(s3)=<class 'set'> In [18]: # Example dictionaries D0 = {} # empty dictionary D1 = {'AM': [54,74,75], 'FM': [103,109], 'ASK': 316, 'FSK': 316, 'PSK': 316, 'QPSK' : 329} D2 = {'apple': 'green', 'mango': 'yellow', 'cherry': 'red', 'apple': 'red'} print('d0={}, type(d0)={}'.format(d0,type(d0))) print('d1={}, type(d1)={}'.format(d1,type(d1))) print('d2={}, type(d2)={}'.format(d2,type(d2))) # note: keys must be unique, only last one is kept D0={}, type(d0)=<class 'dict'> D1={'PSK': 316, 'ASK': 316, 'QPSK': 329, 'FM': [103, 109], 'AM': [54, 74, 75], ' FSK': 316}, type(d1)=<class 'dict'> D2={'mango': 'yellow', 'cherry': 'red', 'apple': 'red'}, type(d2)=<class 'dict'> In [19]: # Get the keys from a dictionary K0 = D0.keys() K1 = D1.keys() K2 = list(d2.keys()) # keys placed in a list print('k0={}, type(k0)={}'.format(k0,type(k0))) print('k1={}, type(k1)={}'.format(k1,type(k1))) print('k2={}, type(k2)={}'.format(k2,type(k2))) K0=dict_keys([]), type(k0)=<class 'dict_keys'> K1=dict_keys(['PSK', 'ASK', 'QPSK', 'FM', 'AM', 'FSK']), type(k1)=<class 'dict_k eys'> K2=['mango', 'cherry', 'apple'], type(k2)=<class 'list'>

7 7 of 7 9/5/2018, 8:51 AM In [20]: # Accessing values in a dictionary print(d1['fm']) print(d1['qpsk']) print(d2['apple'],d2['mango']) [103, 109] 329 red yellow In [21]: # Add/modify/delete a key-value pair D2['peach'] = 'white' # add D2['plum'] = 'purple' # add D2['apple'] = 'green' # modify del D1['FM'] # delete print('d1 = {}'.format(d1)) print('d1 keys: {}'.format(list(d1.keys()))) print('d2 = {}'.format(d2)) print('d2 keys: {}'.format(list(d2.keys()))) D1 = {'PSK': 316, 'ASK': 316, 'QPSK': 329, 'AM': [54, 74, 75], 'FSK': 316} D1 keys: ['PSK', 'ASK', 'QPSK', 'AM', 'FSK'] D2 = {'mango': 'yellow', 'cherry': 'red', 'apple': 'green', 'peach': 'white', 'p lum': 'purple'} D2 keys: ['mango', 'cherry', 'apple', 'peach', 'plum'] In [ ]:

CSCE 110 Programming I Basics of Python: Variables, Expressions, Input/Output

CSCE 110 Programming I Basics of Python: Variables, Expressions, Input/Output Dr. Tiffani L. Williams Department of Computer Science and Engineering Texas A&M University Spring 2011 Python Python was developed