# 字符串复制

`'Hello' * 5   # 必须是整数, 才可复制`
`   'HelloHelloHelloHelloHello`

----赋值

`myName = input('please type your name！\n')`

please type your name！

----·len()用于查看字符串的个数

# len() 查看字符串的个数

```len('hello')
len('hell o')```

5

6

```# 字符串
str(8)```

‘8’

```# 整数
int(2.5)```

2

```# 浮点
float(2)```

2.0

• 练习

# elif否则如果

• elif 条件：
```age = int(input('please enter your age!\n'))   # input() 从屏幕中录入的内容，属于字符串类型
if age < 18:
print('Hi, kids')
elif 40 >= age >= 12:
print('Hi, young man')
elif age > 40:
print('Hi, old man')```

please enter your age!

34

Hi, young man

# while循环

• hello, world练习
```a = 0
if a < 5:
print('Hello, world')
a = a + 1```

Hello, world

```a = 0
while a < 5:
print('Hello, world')
a = a + 1```

Hello, world

Hello, world

Hello, world

Hello, world

Hello, world

• Lucy练习

# Break和continue

```while True:
name = input('Please enter your name!\n')
if name == 'Your name':
break # 跳出循环
print('You are right!')```

Please enter your name!

Your name

You are right!

```while True:
name = input('Who are you?\n')
if name != 'Bob':
continue # 将程序跳转到开头
print('Hello, Bob. What is your password?')
password = input()
if password == 'fish':
break
print('Access granted!')```

# For和range()函数

• 同义的两种写法
```# for 和range（）实现固定的循环次数
for i in range(5):
print(i)
print('Hello world')```

0

Hello world

1

Hello world

2

Hello world

3

Hello world

4

Hello world

```# 等价的while 循环
i = 0
while i < 5:
print(i)
print('Hello world')
i = i + 1```

0

Hello world

1

Hello world

2

Hello world

3

Hello world

4

Hello world

• 累加+=（同义的两种写法）
```# 高斯的1+2+3+...+100=？
total = 0
for i in range(101):
total = total + i
print(total)```

5050

```# 高斯的1+2+3+...+100=？
total = 0
for i in range(101):
total += i
print(total)```

5050

# range()函数（开始、停止、步长）

```for i in range(1, 10, 2):
print(i)```

1

3

5

7

9

• 练习
```# 脑筋急转弯，题目如下
# 100 元钱，5 元铅笔盒，3 元一只笔，0.5 元一块橡皮，将100 元花完，同时三种物品的个数和为100，请用编程解决

# 假设铅笔盒为 x 个，笔为 y 只，橡皮 z 个
print("x y z")
for x in range(1,100,1):
for y in range(1,100,1):
for z in range(1,100,1):
if x + y + z ==100 and 5 * x + 3 * y + 0.5 * z == 100:
print(x, y, z)```

x y z

5 11 84

10 2 88

# 导入模块

import random

• 三种同义写法
```# 当多个模块时，用逗号隔开
import random
for i in range(5):
print(random.randint(1, 10))```

2

9

2

4

10

```import random as rd
for i in range(5):
print(rd.randint(1, 10))```

2

8

5

7

7

```from random import randint
for i in range(5):
print(randint(1, 10))```

6

8

5

6

2

```import sys
import math
import os```
• 综合小例子
```# 综合小例子，控制流的结束，执行完成本身即可结束
import sys
while True:
print('type exit to exit.')
response = input()
if response == 'exit':
sys.exit() # 退出Python 程序
print('Let us have a short break!')```

# 自定义函数

`print("a","b")`

a b

• return和print的区别
```# 自定义函数
def sum(a, b):
c = a + b
print(c)

sum(3, 4)```

7

```# 自定义函数
def sum(a, b):
c = a + b
return(c)

sum(3, 4)```

7

• 随机数练习
```import random
def getAnswer(answerNumber):
if answerNumber == 1:
return 'It is certain'
elif answerNumber == 2:
return 'It is decidely so'
elif answerNumber == 3:
return 'Yes'
elif answerNumber == 4:
return 'Reply hazy try again'
elif answerNumber == 5:
return 'Ask again later'
elif answerNumber == 6:
return 'Concentrate and ask again'
elif answerNumber == 7:
return 'My reply is no'
elif answerNumber == 8:
return 'Outlook not so good'
elif answerNumber == 9:
return 'Very doubtful'

r = random.randint(1, 9)
fortune = getAnswer(r)
print(r, fortune)```

8 Outlook not so good

# 关键字参数 end, sep

`print('cat', 'dog', 'mice', sep='*', end='88888')   # end，sep 就是关键字参数`

cat*dog*mice88888

# 局部和全局作用域

python global语句解析。 如果需要在一个函数内修改全局变量，就使用global语句。 如果在一个函数的顶部有global eggs的代码，就说明eggs指的是全局变量。 或者： 如果在函数中，既没有赋值语句，也没有针对它的global语句，是全局变量。

```def spam():
eggs = 1000
return eggs

spam()```

1000

```# 同理局部变量不能使用其他局部变量
def ehbio():
eggs = 99
spam()
print(eggs)

def spam():
eggs = 0
return eggs

ehbio()```

99

`spam()`

0

```# 全局变量在局部作用域中使用
def spam():
print(eggs)

eggs = 28
spam()```

28

`print(eggs)`

28

```# 尽量避免名称相同的局部变量和全局变量
def spam():
eggs = 'spam local'
print(eggs)  # 输出spam local

def bacon():
eggs = 'bacon local'
print(eggs)  # 输出bacon local
spam()
print(eggs)  # 输出bacon local

eggs = 'global'
bacon()```

bacon local

spam local

bacon local

`print(eggs)   #此处为全局变量eggs`

global

• 总结：

# 列表（List）

1. 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
2. Python有6个序列的内置类型，但最常见的是列表和元组。
3. 序列都可以进行的操作包括索引，切片，加，乘，检查成员。
4. 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
5. 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现.
6. 列表的数据项不需要具有相同的类型
7. 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

## 访问列表中的值：使用下标索引。

```list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7]

print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])   # [1:5]是第2到第4索引```

```list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]```

## 更新列表

```list = []    # 空列表
list.append('google')   #使用append()添加元素
list.append('Runoob')
print(list)```

`['google', 'Runoob']`

## 删除列表元素

```list1 = ['physics', 'chemistry', 1997, 2000]

print(list1)
del(list1[2])
print('After deleting value at index 2 :')
print(list1)```

```['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]```

## 列表脚本操作符

Python 表达式

len([1, 2, 3])

3

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

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

['Hi!'] * 4

['Hi!', 'Hi!', 'Hi!', 'Hi!']

3 in [1, 2, 3]

True

for x in [1, 2, 3]: print x,

1 2 3

## 列表截取

```>>>L = ['Google', 'Runoob', 'Taobao']
>>> L[2] 'Taobao'
>>> L[-2] 'Runoob'
>>> L[1:] ['Runoob', 'Taobao']
>>>```

Python 表达式

L[2]

'Taobao'

L[-2]

'Runoob'

L[1:]

['Runoob', 'Taobao']

L[0:2]

['Google', 'Runoob']

## 列表函数&方法

Python包含以下函数:

1

cmp(list1, list2)比较两个列表的元素

2

len(list)列表元素个数

3

max(list)返回列表元素最大值

4

min(list)返回列表元素最小值

5

list(seq)将元组转换为列表

Python包含以下方法:

1

list.append(obj)在列表末尾添加新的对象

2

list.count(obj)统计某个元素在列表中出现的次数

3

list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

4

list.index(obj)从列表中找出某个值第一个匹配项的索引位置

5

list.insert(index, obj)将对象插入列表

6

list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

7

list.remove(obj)移除列表中某个值的第一个匹配项

8

list.reverse()反向列表中元素

9

list.sort(cmp=None, key=None, reverse=False)对原列表进行排序

booklist = ['Python','Java','PHP']

```append()：向列表尾部添加一个对象
booklist.append('Python Crash Course')```
```insert() :在任何位置添加新元素
booklist.insert(0,'Mysql')    # 在列表开头添加新元素```
```del语句：删除任何位置的元素，删除后，无法再访问
del booklist[1]         # 删除第二个元素```
`pop():  默认末尾的元素，也可根据索引指定`
```remove(): 根据元素的值删除
booklist.remove('Java')         # 删除列表中值为“Java”的元素```

```# sort(): 对列表的值进行排序
booklist.sort()                    # 按照字母排序，排序后无法恢复
booklist.sort(reverse=True)        # 字母反序排序```

['Java', 'PHP', 'Python']

['Python', 'PHP', 'Java']

```sorted(): 临时排序，不影响原始排序
booklist.sorted()                    # 按照字母排序，排序后无法恢复
booklist.sorted(reverse=True)        # 字母反序排序```
```reverse(): 反转列表元素的排序
booklist.reverse()                # 永久性修改，但可再次调用reverse()恢复```

# 字符串和元组

```name = 'python'
name[0:2]```

'py'

`name[-1]`

'n'

`'p' in name`

True

```for i in name:
print(i)```

p

y

t

h

o

n

```# 元组tuple，不可修改
eggs = (1, 2, 'a')
type(eggs)```

<class 'tuple'>

`print(type(('hello')))`

<class 'str'>

`print(type(('hello',)))  # 逗号在元组中起重要作用`

<class 'tuple'>

## tuple和list的转换

```tool = ['python', 'R', 'perl', 'java']
print(tuple(tool))```

('python', 'R', 'perl', 'java')

```a = (1, 3, 4)
print(list(a))```

[1, 3, 4]

# 字典键：值对

```myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
print(myTool)```

{'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}

`print(myTool['first'])`

'python'

# 字典与列表（列表有顺序，字典没有顺序）

```# 默认字典是不排序的, 不能应用下标或者切片取出，而列表是有序列的
a = [1, 2, 3]
b = [2, 1, 3]
print(a == b)```

False

```myTool1 = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
myTool2 = {'first': 'python', 'third': 'linux', 'second': 'R', 'forth': 'perl'}
print(myTool1 == myTool2)```

True

```birthdays = {'Alice': 'Apr 1', 'Bob': 'Dec 12', 'Carol': 'Mar 4'}

while True:
print('Enter a name: (blank to quit)')
name = input()
if name == '':
break

if name in birthdays:
print(birthdays[name] + ' is the birthday of ' + name)
else:
print('I do not have information for ' + name)
print('What is their birthday?')
bday = input()
birthdays[name] = bday
print('Birthday database updated.')```

# keys() values() items()

```myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
for k in myTool.keys():
print(k)```

first

second

third

forth

```myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
for v in myTool.values():
print(v)```

python

R

linux

perl

`print(myTool.items())`

dict_items([('first', 'python'), ('second', 'R'), ('third', 'linux'), ('forth', 'perl')])

```for k, v in myTool.items():
print(k + v)```

firstpython

secondR

thirdlinux

forthperl

`print('first' in myTool)  # 检查字典中是否存在键`

True

```# get()，两个参数分别为“键”，如果没有该键，返回的值
myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
print(myTool.get('first', 0))
print(myTool.get('hello', 0))```

python

0

```# 不使用get()时，如果该键不存在，则报错
myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
print(myTool['hello'])```

Traceback (most recent call last):

File "E:/MyDownloads/Download/pycharm/test/test1.py", line 6, in <module>

print(myTool['hello'])

KeyError: 'hello'

# 字典中若没有该键，则用setdefault()添加

```# setdefault()
myTool = {'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl'}
myTool.setdefault('fifth', 'C')
print(myTool)```

{'first': 'python', 'second': 'R', 'third': 'linux', 'forth': 'perl', 'fifth': 'C'}

```sequece = 'life is short, I use python'
count = {}

for character in sequece:
count.setdefault(character, 0)  # 查询此次计数前此字母出现的次数
count[character] = count[character] + 1  # 更新次数（for每次遍历一个字母，故次数加一）
print(count)

for character in sequece:
count[character] = count.get(character,0) + 1  # 查询出现次数，并加一
print(count)```
```# 简单序列计数
sequece = 'TCGAAATTCGGGCATGGAG'
count = {}

for character in sequece:
count.setdefault(character, 0)
count[character] = count[character] + 1
for k, v in count.items():
print(k + ' ' + str(v))```

# 转义符

\n 换行

\' 单引号

\" 双引号

\\ 倒斜杠

\t 制表符

r 原始字符串：忽略转义符号

```# 字符串切片
a = "life is short, I use python."
print(a)
print(a[1:5])
print(a[-5:-3])
print(a[-3:])
print('python' in a)```

# 字符串方法：大小写

```# 字符串方法
a = "life is short, I use python."
print(a.upper())  # upper()转为大写字母
print(a.lower())  # lower()转为小写字母

b = "HELLO"
print(b.isupper())  # b是否是大写字母
print(a.isupper())  # a是否是大写字母```

# is.X字符串方法

isalpha() 是否只含字母

isalnum() 是否只是字母或数字

isdecimal()是否只有数字

isspace() 是否只有空格制表符换行符

istitle() 是否字符串为开头大写，后面小写

```a = 'by2'
print(a.isalpha())
print(a.isalnum())

b = 'by '
print(b.isalpha())```

False

True

False

```while True:
print('Enter your age:')
age = input()
if age.isdecimal():
break
print('Please enter a number for your age.')

while True:
print('Select a new password (letters or numbers only):')
password = input()
if password.isalnum():
break
print('Passwords can only have letters or numbers.')```

Enter your age:

fv

Please enter a number for your age.

Enter your age:

1

Select a new password (letters or numbers only):

sfdfs s

Passwords can only have letters or numbers.

Select a new password (letters or numbers only):

2

Process finished with exit code 0

# startswith()和endswith()

```seq = '>0001\nTCGATTACGG'
if seq.startswith('>'):
print(seq)
if seq.endswith('CC'):
print(seq)```

>0001

TCGATTACGG

# join()和split()

```# join()和split()
a = ','.join(['I', 'love', 'you'])
print(a)  # 在三个字符中间分别加入逗号
b = '@@@'.join(['I', 'love', 'you'])
print(b)  # 在三个字符中间分别加入@@@
c = 'I love you'
print(c.split())  # 把c以空格为标志拆分
d = 'I*love*you'
print(d.split('*'))  # 把d以*为标志拆分```

# 文本对齐rjust() ljust() center()

```a = 'hello'.rjust(10)  # 调整到一共10个字符，用空格补前边空位
b = 'hello'.rjust(20,'*')  # 调整到一共20个字符，用*补前边空位
c = 'hello'.center(20,'-')  # 调整到一共20个字符，hello位于中间

print(a)
print(b)
print(c)```

hello

***************hello

-------hello--------

```def printpicnic(itemsdict, leftwidth, rightwidth):
print('PICNIC ITEMS'.center(leftwidth + rightwidth, '-'))
for k, v in itemsdict.items():
print(k.ljust(leftwidth, '.') + str(v).rjust(rightwidth))  # 左侧对齐，空位用.补齐；右侧对齐

picnicitems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}
printpicnic(picnicitems, 12, 5)  # 左侧共12个字符，右侧共5个字符
printpicnic(picnicitems, 20, 6)  # 左侧共20个字符，右侧共6个字符```

---PICNIC ITEMS--

sandwiches.. 4

apples...... 12

cups........ 4

cookies..... 8000

-------PICNIC ITEMS-------

sandwiches.......... 4

apples.............. 12

cups................ 4

cookies............. 8000

# strip(), rstrip(), lstrip删除空白字符

```spam = '     hello  '
print(spam)
print(spam.strip())  # 删除结尾的空白字符
print(spam.rstrip())  # 删除右边空白字符
print(spam.lstrip())  # 删除左边空白字符
print(spam.strip('o  '))  # 删除结尾的字符```

# lambda, map, filer, reduce(保留节目)

• lambda 产生一个没有名字的函数， 通常为了满足一次使用， 其使用语法为lambda argument_list:expression。参数列表是用逗号分隔开的一个列表，表达式是这些参数的组合操作。

• map 执行一个循环操作，使用语法为map(func, seq)。第一个参数是要调用的函数或函数的名字，第二个参数是一个序列（如列表、字符串、字典）。map 会以序列的每个元素为参数调用func，并新建一个输出列表。

• filter 用于过滤列表，使用语法为filter(func, list)。以第二个参数的每个元素调用func，返回值为True 则保留，否则舍弃。

• reduce 连续对列表的元素应用函数，使用语法为reduce(func, list)。如果我们有一个列表aList = [1,2,3, … ,n], 调用reduce(func, aList) 后进行的操作为: 首先前两个元素会传入函数func 做运算，返回值替换这两个元素，成为数组第一个元素aList = [func(1,2),3, … , n]; 然后当前的前两个元素再传图func 函数做运算，返回值返回值替换这两个元素，成为数组第一个元素aList = [func(func(1,2),3), … , n]，直到列表只有一个元素。

```print("求和函数")

def f(x, y): return x + y

print(f([1, 2, 3], [4, 5, 6]))
print(f(10, 15))```

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

25

```print("单个参数的map， lambda调用")
aList = [1, 2, 3, 4, 5]
print([x**2 for x in aList])  # 平方**2

print('多个参数的map，lambda调用')
def f(x, y): return x + y

print(list(map(f, [1, 2, 3], [4, 5, 6])))

print('参数为字符串')
print([x.upper() for x in 'acdf'])  # x.upper()  大写字母```

[1, 4, 9, 16, 25]

[5, 7, 9]

['A', 'C', 'D', 'F']

## 奇数、求和、取最大值

```print("输出所有的奇数")
aList = [1, 2, 3, 4, 5]
print([x for x in aList if x % 2])```

[1, 3, 5]

```from functools import reduce
print("列表求和")
aList = [1, 2, 3, 4, 5]
print(reduce(lambda a, b:  a + b, aList))```

15

```from functools import reduce
print("列表取最大值")
aList = [1, 2, 3, 4, 5]
print(reduce(lambda a, b: a if a > b else b, aList))```

5

# exec，eval（执行字符串python语句）

```a = 'print("Executing a string as a command")'  # 括号内外的引号不能相同，否则会报错。
exec(a)  # 执行a```

Executing a string as a command

```a =  'print((2 + 3) * 5)'
eval(a)  # eval用于计算```

25

0 条评论

• ### Match

Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。

• ### python教程

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

• ### 聊聊 print 的前世今生

上周，我翻译了一篇文章，解释了为什么 Python 3 把 print 改为函数？ 概括有如下几点原因：1、print 不适宜作为应用程序级的语句。2、改为一个...

• ### day03

True，False 　　str：存储少量数据，进行操作 　　　　'fjdsal' ，'二哥'，'13243'，'fdshklj' ...

• ### Python中的字符串及用法

字符串是 Python 中最常用的数据类型 1.#字符串的定义 a = 'westos' b = "what's" c = """ 用户管理管理系统 1.添加用...

• ### 【python入门系列课程 第一课 打印一个字符画】

本系列课程是针对无基础的，争取用简单明了的语言来讲解，学习前需要具备基本的电脑操作能力，准备一个已安装python环境的电脑。如果觉得好可以分享转发，有问题的地...

• ### 【Python 第2课】print

今天早上醒来，发现咱们的同学人数一夜之间多了50，后来又陆陆续续来了很多，于是我坚持下去的信心又增加了不少。在这里感谢连客官微的宣传，表示今晚将用加班写代码来表...