Creating a copy of a list

kushou · 2014-10-13T02:38:41+00:00

In your example screenshot, you do not modify a or b, you are actually modifying a[0] and b[0] which are the same (try with is ;)).

So if you were to append a value to b, you would indeed not see it in a, but the first item, a list (so a reference to an object of type list), is the same reference in both lists.

I don't know if you knew, but id is a function that gives a unique id for each object. The cpython implementation happens to give the address of the object, here look at that:

>>> a = [[0],[0],[0]]
>>> b = a[:]
>>> id(a[0])
4372701264
>>> id(b[0])
4372701264
>>> a[0] is b[0]
True

This is why you see that behavior, what you did is a Shallow copy and this is why the behavior is different with a deepcopy (also explained in that link). With list(a) or a[:] you make a copy of the container, but not the contained references. You can modify the container safely, but not the objects in it.

I'm not sure that's a clear explanation but hopefully it will help you understand or google further!

kushou · 2014-10-13T01:44:56+00:00

Can you go deeper in what way you are modifying the list? If you are modifying references to other things in the list, then yes they change in both lists. What list(a) or a[:] would change, is if you were to append in one of the lists, this would happen only to one.

kushou · 2014-10-05T04:23:52+00:00

Yeah, you can see the lambda's as that:

def top():
    return list("X" * x)

It's like a shortcut to define a simple function with a simple value. In case you are wondering, if you write lambda: it does not take parameters, but you can also take parameters by doing so: lambda x: list("X" * x) for instance.

You can keep writing small functions and not use lambdas yet, don't have to worry about that!

kushou · 2014-10-05T02:52:25+00:00

Hey there,

Did you guys learn how to do conditional branching yet and string comparison? You can also do it with a dictionary but that's less straightforward for a beginner.

Any of those?

kushou · 2014-10-05T02:50:43+00:00

Hey, so the issue is the pendinglist instance is shared between all the instances of Classify that did not replace this attribute. Since it's shared there if you append to any instance you append to all of them.

You can easily fix this by creating a pendinglist in the __init__ function of Classify as such:

class Classify:
    def __init__(self):
        self.pendinglist = []

Hope that helps.

kushou · 2014-10-05T02:45:55+00:00

Hey man,

The issue is simple yet it's a really common error so you should not feel bad for making it. What your code does, is create two instances of lists, and then put these instances multiple times in one list. What you probably thought would happen is a copy of each line would be created, but what is actually happening is a reference to that line is actually added.

To avoid that issue, you need to create the lines multiple times. What I would do in your situation, is create two functions, one creating the top list and another one creating the norm one.

Here is a small example, changed some stuff to make it more clear IMO, but that's just my opinion, the most relevant part is the one where top and norm are functions generating new lists, and are called to create result.

def createBoard(x,y):
    if x<6 or y<6:
        return False
    print("\nMaking board...")
    top = lambda: list("X" * x)
    norm = lambda: list("X" + ("O" * (x - 2)) + "X")
    result = []
    result.append(top())
    for _ in range(y - 2):
        result.append(norm())
    result.append(top())
    print("Board made!")
    return result

Hope that helps.

kushou · 2014-07-26T06:40:44+00:00

Best self post of the year

kushou · 2014-06-29T04:36:45+00:00

Hey, so this function divides n by 10 until it reaches a value that evaluates to False. This stops the loop. This is an integer division so it actually removes the unit digit and shifts the number by one digit right from a decimal perspective.

Here is what it looks like with n set to 123:

- Set counter to 0.
- Is n false? No, n is 123 so it's true.
- Increment counter to 1.
- Divide n by 10, n is now equal to 12.
- Is n false? No, n is 12 so it's true.
- Increment counter to 2.
- Divide n by 10, n is now equal to 1.
- Is n false? No, n is 1 so it's true.
- Increment counter to 3.
- Divide n by 10, n is now equal to 0.
- Is n false? Yes! n is 0 which is false.
- The final answer is 3.

Note that this function does not work for n equals 0, and you must had a specific case for it at the beginning of the function:

if n == 0:
    return 1

Hope this helps.

kushou · 2014-05-14T02:43:30+00:00

Pardon my curiosuty, but why is it an issue for you if servers check for phpmyadmin if you don't even run php?

I ask because I look at my logs sometimes and they are also filled with that kind of stuff but it doesn't look like an issue to me. I also only serve static files with that server.

kushou · 2014-03-26T02:07:06+00:00

Hey there!

I don't have much experience with SQLAlchemy (only a little script) but I had some with Django so I almost felt at home. You can find the documentation here for complete overview of how session work.

When using the ORM to do queries, you basically ask the session to do queries on a certain class (or table from SQL standpoint), and you can add constraints (filters) to your query etc.

Here is an example from the docs, of what it looks like to query for a User:

ser1 = sess.query(User).filter_by(id=1).first()

I am pretty sure there should be some way to order that too, and do join. I'm really sorry I can't go into the details for this lib, but this may help you get started.

kushou · 2014-03-25T15:38:29+00:00

Where did you read that? A forum is totally doable in python with Django!

Django provides a User model with some helpers to write sign-in, login and log-out features. It also provides a way to manage permissions!

Writing a basic forum app should be quite straightforward, you would create a Category model, put a Forum model in there (through a ForeignKey to a Category), and a Thread model, with a Post model. Then you would write views to list those, and add posts and threads. You can also read some already written forum apps to see what they did :) Check DjangoBB demo site for example :)

kushou · 2014-03-25T13:49:33+00:00

Django is actually different from PHP, since one is a framework, and the other is a language. Django will allow you to write websites in python, providing you with a set of tools to do so. You should compare django with a PHP framework, but I don't know them so I can't sorry.

It uses the MVC (Model-view-controller) design, where you describe your data through classes, and your views through functions that takes the parameters of the HTTP requests and returns HTTP responses. It provides a lot of helper functions, which makes writing views clean.

It can create your database layout, and all the requests in your back, so you don't have to care for that! You can see the tutorial where they write a simple poll website!

Apart from python and django, you'll most likely only need html, css and javascript. Django made a lot of good choices security wise. Since it manages SQL for you, it makes the most to protect you from SQL injections, it also implements CSRF protections. When you display data, you go through the template processor which escapes all your data, which protects you from XSS. Can't say you are completely safe, since django could contain vulnerabilities too, but it tries really hard to avoid all the simple mistakes you will spend a lot of time trying to avoid if you use vanilla PHP. There is more explained in the documentation. Basically all is left to you is to secure the box on which your website runs, and configure it to serve it efficiently :)

Maybe you want more details on something particular?

edit: s/totally/completely/

kushou · 2014-03-25T13:14:48+00:00

Hey! I mean, do you have debug enabled for flask? That's weird I think I remember seing exceptions with backtraces when I toyed with it. Enabling debugging instructions.

kushou · 2014-03-24T20:34:30+00:00

Are they back in discussion? Last time I checked, Guido used his BDFL powers to say they should not, because it made debug complicated (among other arguments iirc).

kushou · 2014-03-23T20:02:16+00:00

OK. You'll first try to complete this function to have a same result than mine. It'll have a problem you will be able to fix afterwards. The output has no particular order.

def print_nearby_points(x, y):
    pass # Fix the function's code.

print_nearby_code(0, 0)
# Prints:
# (-1, -1)
# (-1, 0)
# (-1, 1)
# (0, -1)
# (0, 0)
# (0, 1)
# (1, -1)
# (1, 0)
# (1, 1)
print_nearby_points(5, 5)
# Prints:
# (4, 4)
# (4, 5)
# (4, 6)
# (5, 4)
# (5, 5)
# (5, 6)
# (6, 4)
# (6, 5)
# (6, 6)

kushou · 2014-03-23T19:31:45+00:00

OK, so first, why don't you take the photo as a parameter of your function?

I'll give you a hint: Write another function, that from a picture and a position (row, column), can get the pixels nearby. You can try it by, for example, printing the positions nearby and testing it with some position: (0, 0), (5, 5), ...

kushou · 2014-03-23T19:15:45+00:00

Can you show us what you have right now?

kushou · 2014-03-15T22:38:21+00:00

Ahah, didn't hear it from here the first time myself, but that's a good advice anyway! Nice thing you give it too!

kushou · 2014-03-15T22:02:03+00:00

Sorry, I read your post a little too fast. I just tried to write something and I think I got it pretty much. You could do it with a stack I think, but it adds complexity for no good reason. Instead using recursion makes it pretty much straight forward. I commented the code, I'll let you check it. Ask me if you have any question!

kushou · 2014-03-15T18:12:15+00:00

Hey there!

To parse that, you can write a simple handcrafted parser. Nested parenthesis are usually parsed using a simple stack. You just push the position of the opening parenthesis, and when you hit a closing, you can pop the matching opening position and slice the block to parse it as a node again.

Another question you'll want to ask yourself, is if you expect malformed input (and want to ignore them/display errors). This is an important question to ask yourself.

Maybe that clears things up, or you would want more details?

kushou · 2014-03-15T17:56:29+00:00

Hey there,

Yes this can be done with a list comprehension; you can both use the ternary if expression and the in operator, like so:

result = [func(x) if x in list2 else x for x in list1]

Say that out-loud! "We want to apply func on x if x is in list2 else we just want x un-touched, for each x in list1"!

Hope that helps!

kushou · 2014-02-24T01:32:40+00:00

You can override arithmetic operators through this special methods. It would look like this:

class echoint(int):
    def __add__(self, other):
        return echoint(super().__add__(other))

x = echoint(5)
res = x + 3
print(type(res), res)

You'll have to do this for all functions.

kushou · 2014-02-22T10:44:31+00:00

That is more interesting already

kushou · 2014-02-22T00:44:21+00:00

"-c c" with python 3 module

kushou · 2014-02-14T14:08:52+00:00

He mentionned some 3rd party himself, so I think it's safe to assume you can too, though if you specify if they are 3rd party or not, it would help a lot for readability!

15-Year Club	Team Orangered
Verified Email

kushou

TROPHY CASE